The Tor Browser: uriloader/exthandler/unix/nsOSHelperAppService.cpp@6474c204b198 (annotated)

uriloader/exthandler/unix/nsOSHelperAppService.cpp@6474c204b198 (annotated)

uriloader/exthandler/unix/nsOSHelperAppService.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 <sys/types.h>
 #include <sys/stat.h>
 #if defined(MOZ_ENABLE_CONTENTACTION)
 #include <contentaction/contentaction.h>
 #include <QString>
 #endif
 #include "nsOSHelperAppService.h"
 #include "nsMIMEInfoUnix.h"
 #ifdef MOZ_WIDGET_GTK
 #include "nsGNOMERegistry.h"
 #endif
 #include "nsISupports.h"
 #include "nsString.h"
 #include "nsReadableUtils.h"
 #include "nsUnicharUtils.h"
 #include "nsXPIDLString.h"
 #include "nsIURL.h"
 #include "nsIFileStreams.h"
 #include "nsILineInputStream.h"
 #include "nsIFile.h"
 #include "nsIProcess.h"
 #include "nsNetCID.h"
 #include "nsXPCOM.h"
 #include "nsISupportsPrimitives.h"
 #include "nsCRT.h"
 #include "nsDirectoryServiceDefs.h"
 #include "nsDirectoryServiceUtils.h"
 #include "prenv.h"      // for PR_GetEnv()
 #include "nsAutoPtr.h"
 #include "mozilla/Preferences.h"
 using namespace mozilla;
 #define LOG(args) PR_LOG(mLog, PR_LOG_DEBUG, args)
 #define LOG_ENABLED() PR_LOG_TEST(mLog, PR_LOG_DEBUG)
 static nsresult
 FindSemicolon(nsAString::const_iterator& aSemicolon_iter,
               const nsAString::const_iterator& aEnd_iter);
 static nsresult
 ParseMIMEType(const nsAString::const_iterator& aStart_iter,
               nsAString::const_iterator& aMajorTypeStart,
               nsAString::const_iterator& aMajorTypeEnd,
               nsAString::const_iterator& aMinorTypeStart,
               nsAString::const_iterator& aMinorTypeEnd,
               const nsAString::const_iterator& aEnd_iter);
 inline bool
 IsNetscapeFormat(const nsACString& aBuffer);
 nsOSHelperAppService::nsOSHelperAppService() : nsExternalHelperAppService()
 {
   mode_t mask = umask(0777);
   umask(mask);
   mPermissions = 0666 & ~mask;
 }
 nsOSHelperAppService::~nsOSHelperAppService()
 {}
 /*
  * Take a command with all the mailcap escapes in it and unescape it
  * Ideally this needs the mime type, mime type options, and location of the
  * temporary file, but this last can't be got from here
  */
 // static
 nsresult
 nsOSHelperAppService::UnescapeCommand(const nsAString& aEscapedCommand,
                                       const nsAString& aMajorType,
                                       const nsAString& aMinorType,
                                       nsACString& aUnEscapedCommand) {
   LOG(("-- UnescapeCommand"));
   LOG(("Command to escape: '%s'\n",
        NS_LossyConvertUTF16toASCII(aEscapedCommand).get()));
   //  XXX This function will need to get the mime type and various stuff like that being passed in to work properly
   LOG(("UnescapeCommand really needs some work -- it should actually do some unescaping\n"));
   CopyUTF16toUTF8(aEscapedCommand, aUnEscapedCommand);
   LOG(("Escaped command: '%s'\n",
        PromiseFlatCString(aUnEscapedCommand).get()));
   return NS_OK;
 }
 /* Put aSemicolon_iter at the first non-escaped semicolon after
  * aStart_iter but before aEnd_iter
  */
 static nsresult
 FindSemicolon(nsAString::const_iterator& aSemicolon_iter,
               const nsAString::const_iterator& aEnd_iter) {
   bool semicolonFound = false;
   while (aSemicolon_iter != aEnd_iter && !semicolonFound) {
     switch(*aSemicolon_iter) {
     case '\\':
       aSemicolon_iter.advance(2);
       break;
     case ';':
       semicolonFound = true;
       break;
     default:
       ++aSemicolon_iter;
       break;
     }
   }
   return NS_OK;
 }
 static nsresult
 ParseMIMEType(const nsAString::const_iterator& aStart_iter,
               nsAString::const_iterator& aMajorTypeStart,
               nsAString::const_iterator& aMajorTypeEnd,
               nsAString::const_iterator& aMinorTypeStart,
               nsAString::const_iterator& aMinorTypeEnd,
               const nsAString::const_iterator& aEnd_iter) {
   nsAString::const_iterator iter(aStart_iter);
   // skip leading whitespace
   while (iter != aEnd_iter && nsCRT::IsAsciiSpace(*iter)) {
     ++iter;
   }
   if (iter == aEnd_iter) {
     return NS_ERROR_INVALID_ARG;
   }
   aMajorTypeStart = iter;
   // find major/minor separator ('/')
   while (iter != aEnd_iter && *iter != '/') {
     ++iter;
   }
   if (iter == aEnd_iter) {
     return NS_ERROR_INVALID_ARG;
   }
   aMajorTypeEnd = iter;
   // skip '/'
   ++iter;
   if (iter == aEnd_iter) {
     return NS_ERROR_INVALID_ARG;
   }
   aMinorTypeStart = iter;
   // find end of minor type, delimited by whitespace or ';'
   while (iter != aEnd_iter && !nsCRT::IsAsciiSpace(*iter) && *iter != ';') {
     ++iter;
   }
   aMinorTypeEnd = iter;
   return NS_OK;
 }
 // static
 nsresult
 nsOSHelperAppService::GetFileLocation(const char* aPrefName,
                                       const char* aEnvVarName,
                                       nsAString& aFileLocation) {
   LOG(("-- GetFileLocation.  Pref: '%s'  EnvVar: '%s'\n",
        aPrefName,
        aEnvVarName));
   NS_PRECONDITION(aPrefName, "Null pref name passed; don't do that!");
   aFileLocation.Truncate();
   /* The lookup order is:
 ) user pref
 ) env var
 ) pref
   */
   NS_ENSURE_TRUE(Preferences::GetRootBranch(), NS_ERROR_FAILURE);
   /*
     If we have an env var we should check whether the pref is a user
     pref.  If we do not, we don't care.
   */
   if (Preferences::HasUserValue(aPrefName) &&
       NS_SUCCEEDED(Preferences::GetString(aPrefName, &aFileLocation))) {
     return NS_OK;
   }
   if (aEnvVarName && *aEnvVarName) {
     char* prefValue = PR_GetEnv(aEnvVarName);
     if (prefValue && *prefValue) {
       // the pref is in the system charset and it's a filepath... The
       // natural way to do the charset conversion is by just initing
       // an nsIFile with the native path and asking it for the Unicode
       // version.
       nsresult rv;
       nsCOMPtr<nsIFile> file(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv));
       NS_ENSURE_SUCCESS(rv, rv);
       rv = file->InitWithNativePath(nsDependentCString(prefValue));
       NS_ENSURE_SUCCESS(rv, rv);
       rv = file->GetPath(aFileLocation);
       NS_ENSURE_SUCCESS(rv, rv);
       return NS_OK;
     }
   }
   return Preferences::GetString(aPrefName, &aFileLocation);
 }
 /* Get the mime.types file names from prefs and look up info in them
    based on extension */
 // static
 nsresult
 nsOSHelperAppService::LookUpTypeAndDescription(const nsAString& aFileExtension,
                                                nsAString& aMajorType,
                                                nsAString& aMinorType,
                                                nsAString& aDescription,
                                                bool aUserData) {
   LOG(("-- LookUpTypeAndDescription for extension '%s'\n",
        NS_LossyConvertUTF16toASCII(aFileExtension).get()));
   nsresult rv = NS_OK;
   nsAutoString mimeFileName;
   const char* filenamePref = aUserData ?
     "helpers.private_mime_types_file" : "helpers.global_mime_types_file";
   rv = GetFileLocation(filenamePref, nullptr, mimeFileName);
   if (NS_SUCCEEDED(rv) && !mimeFileName.IsEmpty()) {
     rv = GetTypeAndDescriptionFromMimetypesFile(mimeFileName,
                                                 aFileExtension,
                                                 aMajorType,
                                                 aMinorType,
                                                 aDescription);
   } else {
     rv = NS_ERROR_NOT_AVAILABLE;
   }
   return rv;
 }
 inline bool
 IsNetscapeFormat(const nsACString& aBuffer) {
   return StringBeginsWith(aBuffer, NS_LITERAL_CSTRING("#--Netscape Communications Corporation MIME Information")) ||
          StringBeginsWith(aBuffer, NS_LITERAL_CSTRING("#--MCOM MIME Information"));
 }
 /*
  * Create a file stream and line input stream for the filename.
  * Leaves the first line of the file in aBuffer and sets the format to
  *  true for netscape files and false for normail ones
  */
 // static
 nsresult
 nsOSHelperAppService::CreateInputStream(const nsAString& aFilename,
                                         nsIFileInputStream ** aFileInputStream,
                                         nsILineInputStream ** aLineInputStream,
                                         nsACString& aBuffer,
                                         bool * aNetscapeFormat,
                                         bool * aMore) {
   LOG(("-- CreateInputStream"));
   nsresult rv = NS_OK;
   nsCOMPtr<nsIFile> file(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv));
   if (NS_FAILED(rv))
     return rv;
   rv = file->InitWithPath(aFilename);
   if (NS_FAILED(rv))
     return rv;
   nsCOMPtr<nsIFileInputStream> fileStream(do_CreateInstance(NS_LOCALFILEINPUTSTREAM_CONTRACTID, &rv));
   if (NS_FAILED(rv))
     return rv;
   rv = fileStream->Init(file, -1, -1, false);
   if (NS_FAILED(rv))
     return rv;
   nsCOMPtr<nsILineInputStream> lineStream(do_QueryInterface(fileStream, &rv));
   if (NS_FAILED(rv)) {
     LOG(("Interface trouble in stream land!"));
     return rv;
   }
   rv = lineStream->ReadLine(aBuffer, aMore);
   if (NS_FAILED(rv)) {
     fileStream->Close();
     return rv;
   }
   *aNetscapeFormat = IsNetscapeFormat(aBuffer);
   *aFileInputStream = fileStream;
   NS_ADDREF(*aFileInputStream);
   *aLineInputStream = lineStream;
   NS_ADDREF(*aLineInputStream);
   return NS_OK;
 }
 /* Open the file, read the first line, decide what type of file it is,
    then get info based on extension */
 // static
 nsresult
 nsOSHelperAppService::GetTypeAndDescriptionFromMimetypesFile(const nsAString& aFilename,
                                                              const nsAString& aFileExtension,
                                                              nsAString& aMajorType,
                                                              nsAString& aMinorType,
                                                              nsAString& aDescription) {
   LOG(("-- GetTypeAndDescriptionFromMimetypesFile\n"));
   LOG(("Getting type and description from types file '%s'\n",
        NS_LossyConvertUTF16toASCII(aFilename).get()));
   LOG(("Using extension '%s'\n",
        NS_LossyConvertUTF16toASCII(aFileExtension).get()));
   nsresult rv = NS_OK;
   nsCOMPtr<nsIFileInputStream> mimeFile;
   nsCOMPtr<nsILineInputStream> mimeTypes;
   bool netscapeFormat;
   nsAutoString buf;
   nsAutoCString cBuf;
   bool more = false;
   rv = CreateInputStream(aFilename, getter_AddRefs(mimeFile), getter_AddRefs(mimeTypes),
                          cBuf, &netscapeFormat, &more);
   if (NS_FAILED(rv)) {
     return rv;
   }
   nsAutoString extensions;
   nsString entry;
   entry.SetCapacity(100);
   nsAString::const_iterator majorTypeStart, majorTypeEnd,
                             minorTypeStart, minorTypeEnd,
                             descriptionStart, descriptionEnd;
   do {
     CopyASCIItoUTF16(cBuf, buf);
     // read through, building up an entry.  If we finish an entry, check for
     // a match and return out of the loop if we match
     // skip comments and empty lines
     if (!buf.IsEmpty() && buf.First() != '#') {
       entry.Append(buf);
       if (entry.Last() == '\\') {
         entry.Truncate(entry.Length() - 1);
         entry.Append(char16_t(' '));  // in case there is no trailing whitespace on this line
       } else {  // we have a full entry
         LOG(("Current entry: '%s'\n",
              NS_LossyConvertUTF16toASCII(entry).get()));
         if (netscapeFormat) {
           rv = ParseNetscapeMIMETypesEntry(entry,
                                            majorTypeStart, majorTypeEnd,
                                            minorTypeStart, minorTypeEnd,
                                            extensions,
                                            descriptionStart, descriptionEnd);
           if (NS_FAILED(rv)) {
             // We sometimes get things like RealPlayer appending
             // "normal" entries to "Netscape" .mime.types files.  Try
             // to handle that.  Bug 106381.
             LOG(("Bogus entry; trying 'normal' mode\n"));
             rv = ParseNormalMIMETypesEntry(entry,
                                            majorTypeStart, majorTypeEnd,
                                            minorTypeStart, minorTypeEnd,
                                            extensions,
                                            descriptionStart, descriptionEnd);
           }
         } else {
           rv = ParseNormalMIMETypesEntry(entry,
                                          majorTypeStart, majorTypeEnd,
                                          minorTypeStart, minorTypeEnd,
                                          extensions,
                                          descriptionStart, descriptionEnd);
           if (NS_FAILED(rv)) {
             // We sometimes get things like StarOffice prepending
             // "normal" entries to "Netscape" .mime.types files.  Try
             // to handle that.  Bug 136670.
             LOG(("Bogus entry; trying 'Netscape' mode\n"));
             rv = ParseNetscapeMIMETypesEntry(entry,
                                              majorTypeStart, majorTypeEnd,
                                              minorTypeStart, minorTypeEnd,
                                              extensions,
                                              descriptionStart, descriptionEnd);
           }
         }
         if (NS_SUCCEEDED(rv)) { // entry parses
           nsAString::const_iterator start, end;
           extensions.BeginReading(start);
           extensions.EndReading(end);
           nsAString::const_iterator iter(start);
           while (start != end) {
             FindCharInReadable(',', iter, end);
             if (Substring(start, iter).Equals(aFileExtension,
                                               nsCaseInsensitiveStringComparator())) {
               // it's a match.  Assign the type and description and run
               aMajorType.Assign(Substring(majorTypeStart, majorTypeEnd));
               aMinorType.Assign(Substring(minorTypeStart, minorTypeEnd));
               aDescription.Assign(Substring(descriptionStart, descriptionEnd));
               mimeFile->Close();
               return NS_OK;
             }
             if (iter != end) {
               ++iter;
             }
             start = iter;
           }
         } else {
           LOG(("Failed to parse entry: %s\n", NS_LossyConvertUTF16toASCII(entry).get()));
         }
         // truncate the entry for the next iteration
         entry.Truncate();
       }
     }
     if (!more) {
       rv = NS_ERROR_NOT_AVAILABLE;
       break;
     }
     // read the next line
     rv = mimeTypes->ReadLine(cBuf, &more);
   } while (NS_SUCCEEDED(rv));
   mimeFile->Close();
   return rv;
 }
 /* Get the mime.types file names from prefs and look up info in them
    based on mimetype  */
 // static
 nsresult
 nsOSHelperAppService::LookUpExtensionsAndDescription(const nsAString& aMajorType,
                                                      const nsAString& aMinorType,
                                                      nsAString& aFileExtensions,
                                                      nsAString& aDescription) {
   LOG(("-- LookUpExtensionsAndDescription for type '%s/%s'\n",
        NS_LossyConvertUTF16toASCII(aMajorType).get(),
        NS_LossyConvertUTF16toASCII(aMinorType).get()));
   nsresult rv = NS_OK;
   nsAutoString mimeFileName;
   rv = GetFileLocation("helpers.private_mime_types_file", nullptr, mimeFileName);
   if (NS_SUCCEEDED(rv) && !mimeFileName.IsEmpty()) {
     rv = GetExtensionsAndDescriptionFromMimetypesFile(mimeFileName,
                                                       aMajorType,
                                                       aMinorType,
                                                       aFileExtensions,
                                                       aDescription);
   } else {
     rv = NS_ERROR_NOT_AVAILABLE;
   }
   if (NS_FAILED(rv) || aFileExtensions.IsEmpty()) {
     rv = GetFileLocation("helpers.global_mime_types_file",
                          nullptr, mimeFileName);
     if (NS_SUCCEEDED(rv) && !mimeFileName.IsEmpty()) {
       rv = GetExtensionsAndDescriptionFromMimetypesFile(mimeFileName,
                                                         aMajorType,
                                                         aMinorType,
                                                         aFileExtensions,
                                                         aDescription);
     } else {
       rv = NS_ERROR_NOT_AVAILABLE;
     }
   }
   return rv;
 }
 /* Open the file, read the first line, decide what type of file it is,
    then get info based on extension */
 // static
 nsresult
 nsOSHelperAppService::GetExtensionsAndDescriptionFromMimetypesFile(const nsAString& aFilename,
                                                                    const nsAString& aMajorType,
                                                                    const nsAString& aMinorType,
                                                                    nsAString& aFileExtensions,
                                                                    nsAString& aDescription) {
   LOG(("-- GetExtensionsAndDescriptionFromMimetypesFile\n"));
   LOG(("Getting extensions and description from types file '%s'\n",
        NS_LossyConvertUTF16toASCII(aFilename).get()));
   LOG(("Using type '%s/%s'\n",
        NS_LossyConvertUTF16toASCII(aMajorType).get(),
        NS_LossyConvertUTF16toASCII(aMinorType).get()));
   nsresult rv = NS_OK;
   nsCOMPtr<nsIFileInputStream> mimeFile;
   nsCOMPtr<nsILineInputStream> mimeTypes;
   bool netscapeFormat;
   nsAutoCString cBuf;
   nsAutoString buf;
   bool more = false;
   rv = CreateInputStream(aFilename, getter_AddRefs(mimeFile), getter_AddRefs(mimeTypes),
                          cBuf, &netscapeFormat, &more);
   if (NS_FAILED(rv)) {
     return rv;
   }
   nsAutoString extensions;
   nsString entry;
   entry.SetCapacity(100);
   nsAString::const_iterator majorTypeStart, majorTypeEnd,
                             minorTypeStart, minorTypeEnd,
                             descriptionStart, descriptionEnd;
   do {
     CopyASCIItoUTF16(cBuf, buf);
     // read through, building up an entry.  If we finish an entry, check for
     // a match and return out of the loop if we match
     // skip comments and empty lines
     if (!buf.IsEmpty() && buf.First() != '#') {
       entry.Append(buf);
       if (entry.Last() == '\\') {
         entry.Truncate(entry.Length() - 1);
         entry.Append(char16_t(' '));  // in case there is no trailing whitespace on this line
       } else {  // we have a full entry
         LOG(("Current entry: '%s'\n",
              NS_LossyConvertUTF16toASCII(entry).get()));
         if (netscapeFormat) {
           rv = ParseNetscapeMIMETypesEntry(entry,
                                            majorTypeStart, majorTypeEnd,
                                            minorTypeStart, minorTypeEnd,
                                            extensions,
                                            descriptionStart, descriptionEnd);
           if (NS_FAILED(rv)) {
             // We sometimes get things like RealPlayer appending
             // "normal" entries to "Netscape" .mime.types files.  Try
             // to handle that.  Bug 106381.
             LOG(("Bogus entry; trying 'normal' mode\n"));
             rv = ParseNormalMIMETypesEntry(entry,
                                            majorTypeStart, majorTypeEnd,
                                            minorTypeStart, minorTypeEnd,
                                            extensions,
                                            descriptionStart, descriptionEnd);
           }
         } else {
           rv = ParseNormalMIMETypesEntry(entry,
                                          majorTypeStart, majorTypeEnd,
                                          minorTypeStart,
                                          minorTypeEnd, extensions,
                                          descriptionStart, descriptionEnd);
           if (NS_FAILED(rv)) {
             // We sometimes get things like StarOffice prepending
             // "normal" entries to "Netscape" .mime.types files.  Try
             // to handle that.  Bug 136670.
             LOG(("Bogus entry; trying 'Netscape' mode\n"));
             rv = ParseNetscapeMIMETypesEntry(entry,
                                              majorTypeStart, majorTypeEnd,
                                              minorTypeStart, minorTypeEnd,
                                              extensions,
                                              descriptionStart, descriptionEnd);
           }
         }
         if (NS_SUCCEEDED(rv) &&
             Substring(majorTypeStart,
                       majorTypeEnd).Equals(aMajorType,
                                            nsCaseInsensitiveStringComparator())&&
             Substring(minorTypeStart,
                       minorTypeEnd).Equals(aMinorType,
                                            nsCaseInsensitiveStringComparator())) {
           // it's a match
           aFileExtensions.Assign(extensions);
           aDescription.Assign(Substring(descriptionStart, descriptionEnd));
           mimeFile->Close();
           return NS_OK;
         } else if (NS_FAILED(rv)) {
           LOG(("Failed to parse entry: %s\n", NS_LossyConvertUTF16toASCII(entry).get()));
         }
         entry.Truncate();
       }
     }
     if (!more) {
       rv = NS_ERROR_NOT_AVAILABLE;
       break;
     }
     // read the next line
     rv = mimeTypes->ReadLine(cBuf, &more);
   } while (NS_SUCCEEDED(rv));
   mimeFile->Close();
   return rv;
 }
 /*
  * This parses a Netscape format mime.types entry.  There are two
  * possible formats:
  *
  * type=foo/bar; options exts="baz" description="Some type"
  *
  * and
  *
  * type=foo/bar; options description="Some type" exts="baz"
  */
 // static
 nsresult
 nsOSHelperAppService::ParseNetscapeMIMETypesEntry(const nsAString& aEntry,
                                                   nsAString::const_iterator& aMajorTypeStart,
                                                   nsAString::const_iterator& aMajorTypeEnd,
                                                   nsAString::const_iterator& aMinorTypeStart,
                                                   nsAString::const_iterator& aMinorTypeEnd,
                                                   nsAString& aExtensions,
                                                   nsAString::const_iterator& aDescriptionStart,
                                                   nsAString::const_iterator& aDescriptionEnd) {
   LOG(("-- ParseNetscapeMIMETypesEntry\n"));
   NS_ASSERTION(!aEntry.IsEmpty(), "Empty Netscape MIME types entry being parsed.");
   nsAString::const_iterator start_iter, end_iter, match_start, match_end;
   aEntry.BeginReading(start_iter);
   aEntry.EndReading(end_iter);
   // skip trailing whitespace
   do {
     --end_iter;
   } while (end_iter != start_iter &&
            nsCRT::IsAsciiSpace(*end_iter));
   // if we're pointing to a quote, don't advance -- we don't want to
   // include the quote....
   if (*end_iter != '"')
     ++end_iter;
   match_start = start_iter;
   match_end = end_iter;
   // Get the major and minor types
   // First the major type
   if (! FindInReadable(NS_LITERAL_STRING("type="), match_start, match_end)) {
     return NS_ERROR_FAILURE;
   }
   match_start = match_end;
   while (match_end != end_iter &&
          *match_end != '/') {
     ++match_end;
   }
   if (match_end == end_iter) {
     return NS_ERROR_FAILURE;
   }
   aMajorTypeStart = match_start;
   aMajorTypeEnd = match_end;
   // now the minor type
   if (++match_end == end_iter) {
     return NS_ERROR_FAILURE;
   }
   match_start = match_end;
   while (match_end != end_iter &&
          !nsCRT::IsAsciiSpace(*match_end) &&
          *match_end != ';') {
     ++match_end;
   }
   if (match_end == end_iter) {
     return NS_ERROR_FAILURE;
   }
   aMinorTypeStart = match_start;
   aMinorTypeEnd = match_end;
   // ignore everything up to the end of the mime type from here on
   start_iter = match_end;
   // get the extensions
   match_start = match_end;
   match_end = end_iter;
   if (FindInReadable(NS_LITERAL_STRING("exts="), match_start, match_end)) {
     nsAString::const_iterator extStart, extEnd;
     if (match_end == end_iter ||
         (*match_end == '"' && ++match_end == end_iter)) {
       return NS_ERROR_FAILURE;
     }
     extStart = match_end;
     match_start = extStart;
     match_end = end_iter;
     if (FindInReadable(NS_LITERAL_STRING("desc=\""), match_start, match_end)) {
       // exts= before desc=, so we have to find the actual end of the extensions
       extEnd = match_start;
       if (extEnd == extStart) {
         return NS_ERROR_FAILURE;
       }
       do {
         --extEnd;
       } while (extEnd != extStart &&
                nsCRT::IsAsciiSpace(*extEnd));
       if (extEnd != extStart && *extEnd == '"') {
         --extEnd;
       }
     } else {
       // desc= before exts=, so we can use end_iter as the end of the extensions
       extEnd = end_iter;
     }
     aExtensions = Substring(extStart, extEnd);
   } else {
     // no extensions
     aExtensions.Truncate();
   }
   // get the description
   match_start = start_iter;
   match_end = end_iter;
   if (FindInReadable(NS_LITERAL_STRING("desc=\""), match_start, match_end)) {
     aDescriptionStart = match_end;
     match_start = aDescriptionStart;
     match_end = end_iter;
     if (FindInReadable(NS_LITERAL_STRING("exts="), match_start, match_end)) {
       // exts= after desc=, so have to find actual end of description
       aDescriptionEnd = match_start;
       if (aDescriptionEnd == aDescriptionStart) {
         return NS_ERROR_FAILURE;
       }
       do {
         --aDescriptionEnd;
       } while (aDescriptionEnd != aDescriptionStart &&
                nsCRT::IsAsciiSpace(*aDescriptionEnd));
       if (aDescriptionStart != aDescriptionStart && *aDescriptionEnd == '"') {
         --aDescriptionEnd;
       }
     } else {
       // desc= after exts=, so use end_iter for the description end
       aDescriptionEnd = end_iter;
     }
   } else {
     // no description
     aDescriptionStart = start_iter;
     aDescriptionEnd = start_iter;
   }
   return NS_OK;
 }
 /*
  * This parses a normal format mime.types entry.  The format is:
  *
  * major/minor    ext1 ext2 ext3
  */
 // static
 nsresult
 nsOSHelperAppService::ParseNormalMIMETypesEntry(const nsAString& aEntry,
                                                 nsAString::const_iterator& aMajorTypeStart,
                                                 nsAString::const_iterator& aMajorTypeEnd,
                                                 nsAString::const_iterator& aMinorTypeStart,
                                                 nsAString::const_iterator& aMinorTypeEnd,
                                                 nsAString& aExtensions,
                                                 nsAString::const_iterator& aDescriptionStart,
                                                 nsAString::const_iterator& aDescriptionEnd) {
   LOG(("-- ParseNormalMIMETypesEntry\n"));
   NS_ASSERTION(!aEntry.IsEmpty(), "Empty Normal MIME types entry being parsed.");
   nsAString::const_iterator start_iter, end_iter, iter;
   aEntry.BeginReading(start_iter);
   aEntry.EndReading(end_iter);
   // no description
   aDescriptionStart = start_iter;
   aDescriptionEnd = start_iter;
   // skip leading whitespace
   while (start_iter != end_iter && nsCRT::IsAsciiSpace(*start_iter)) {
     ++start_iter;
   }
   if (start_iter == end_iter) {
     return NS_ERROR_FAILURE;
   }
   // skip trailing whitespace
   do {
     --end_iter;
   } while (end_iter != start_iter && nsCRT::IsAsciiSpace(*end_iter));
   ++end_iter; // point to first whitespace char (or to end of string)
   iter = start_iter;
   // get the major type
   if (! FindCharInReadable('/', iter, end_iter))
     return NS_ERROR_FAILURE;
   nsAString::const_iterator equals_sign_iter(start_iter);
   if (FindCharInReadable('=', equals_sign_iter, iter))
     return NS_ERROR_FAILURE; // see bug 136670
   aMajorTypeStart = start_iter;
   aMajorTypeEnd = iter;
   // get the minor type
   if (++iter == end_iter) {
     return NS_ERROR_FAILURE;
   }
   start_iter = iter;
   while (iter != end_iter && !nsCRT::IsAsciiSpace(*iter)) {
     ++iter;
   }
   aMinorTypeStart = start_iter;
   aMinorTypeEnd = iter;
   // get the extensions
   aExtensions.Truncate();
   while (iter != end_iter) {
     while (iter != end_iter && nsCRT::IsAsciiSpace(*iter)) {
       ++iter;
     }
     start_iter = iter;
     while (iter != end_iter && !nsCRT::IsAsciiSpace(*iter)) {
       ++iter;
     }
     aExtensions.Append(Substring(start_iter, iter));
     if (iter != end_iter) { // not the last extension
       aExtensions.Append(char16_t(','));
     }
   }
   return NS_OK;
 }
 // static
 nsresult
 nsOSHelperAppService::LookUpHandlerAndDescription(const nsAString& aMajorType,
                                                   const nsAString& aMinorType,
                                                   nsAString& aHandler,
                                                   nsAString& aDescription,
                                                   nsAString& aMozillaFlags) {
   // The mailcap lookup is two-pass to handle the case of mailcap files
   // that have something like:
   //
   // text/*; emacs %s
   // text/rtf; soffice %s
   //
   // in that order.  We want to pick up "soffice" for text/rtf in such cases
   nsresult rv = DoLookUpHandlerAndDescription(aMajorType,
                                               aMinorType,
                                               aHandler,
                                               aDescription,
                                               aMozillaFlags,
                                               true);
   if (NS_FAILED(rv)) {
     rv = DoLookUpHandlerAndDescription(aMajorType,
                                        aMinorType,
                                        aHandler,
                                        aDescription,
                                        aMozillaFlags,
                                        false);
   }
   // maybe we have an entry for "aMajorType/*"?
   if (NS_FAILED(rv)) {
     rv = DoLookUpHandlerAndDescription(aMajorType,
                                        NS_LITERAL_STRING("*"),
                                        aHandler,
                                        aDescription,
                                        aMozillaFlags,
                                        true);
   }
   if (NS_FAILED(rv)) {
     rv = DoLookUpHandlerAndDescription(aMajorType,
                                        NS_LITERAL_STRING("*"),
                                        aHandler,
                                        aDescription,
                                        aMozillaFlags,
                                        false);
   }
   return rv;
 }
 // static
 nsresult
 nsOSHelperAppService::DoLookUpHandlerAndDescription(const nsAString& aMajorType,
                                                     const nsAString& aMinorType,
                                                     nsAString& aHandler,
                                                     nsAString& aDescription,
                                                     nsAString& aMozillaFlags,
                                                     bool aUserData) {
   LOG(("-- LookUpHandlerAndDescription for type '%s/%s'\n",
        NS_LossyConvertUTF16toASCII(aMajorType).get(),
        NS_LossyConvertUTF16toASCII(aMinorType).get()));
   nsresult rv = NS_OK;
   nsAutoString mailcapFileName;
   const char * filenamePref = aUserData ?
     "helpers.private_mailcap_file" : "helpers.global_mailcap_file";
   const char * filenameEnvVar = aUserData ?
     "PERSONAL_MAILCAP" : "MAILCAP";
   rv = GetFileLocation(filenamePref, filenameEnvVar, mailcapFileName);
   if (NS_SUCCEEDED(rv) && !mailcapFileName.IsEmpty()) {
     rv = GetHandlerAndDescriptionFromMailcapFile(mailcapFileName,
                                                  aMajorType,
                                                  aMinorType,
                                                  aHandler,
                                                  aDescription,
                                                  aMozillaFlags);
   } else {
     rv = NS_ERROR_NOT_AVAILABLE;
   }
   return rv;
 }
 // static
 nsresult
 nsOSHelperAppService::GetHandlerAndDescriptionFromMailcapFile(const nsAString& aFilename,
                                                               const nsAString& aMajorType,
                                                               const nsAString& aMinorType,
                                                               nsAString& aHandler,
                                                               nsAString& aDescription,
                                                               nsAString& aMozillaFlags) {
   LOG(("-- GetHandlerAndDescriptionFromMailcapFile\n"));
   LOG(("Getting handler and description from mailcap file '%s'\n",
        NS_LossyConvertUTF16toASCII(aFilename).get()));
   LOG(("Using type '%s/%s'\n",
        NS_LossyConvertUTF16toASCII(aMajorType).get(),
        NS_LossyConvertUTF16toASCII(aMinorType).get()));
   nsresult rv = NS_OK;
   bool more = false;
   nsCOMPtr<nsIFile> file(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv));
   if (NS_FAILED(rv))
     return rv;
   rv = file->InitWithPath(aFilename);
   if (NS_FAILED(rv))
     return rv;
   nsCOMPtr<nsIFileInputStream> mailcapFile(do_CreateInstance(NS_LOCALFILEINPUTSTREAM_CONTRACTID, &rv));
   if (NS_FAILED(rv))
     return rv;
   rv = mailcapFile->Init(file, -1, -1, false);
   if (NS_FAILED(rv))
     return rv;
   nsCOMPtr<nsILineInputStream> mailcap (do_QueryInterface(mailcapFile, &rv));
   if (NS_FAILED(rv)) {
     LOG(("Interface trouble in stream land!"));
     return rv;
   }
   nsString entry, buffer;
   nsAutoCString cBuffer;
   entry.SetCapacity(128);
   cBuffer.SetCapacity(80);
   rv = mailcap->ReadLine(cBuffer, &more);
   if (NS_FAILED(rv)) {
     mailcapFile->Close();
     return rv;
   }
   do {  // return on end-of-file in the loop
     CopyASCIItoUTF16(cBuffer, buffer);
     if (!buffer.IsEmpty() && buffer.First() != '#') {
       entry.Append(buffer);
       if (entry.Last() == '\\') {  // entry continues on next line
         entry.Truncate(entry.Length()-1);
         entry.Append(char16_t(' ')); // in case there is no trailing whitespace on this line
       } else {  // we have a full entry in entry.  Check it for the type
         LOG(("Current entry: '%s'\n",
              NS_LossyConvertUTF16toASCII(entry).get()));
         nsAString::const_iterator semicolon_iter,
                                   start_iter, end_iter,
                                   majorTypeStart, majorTypeEnd,
                                   minorTypeStart, minorTypeEnd;
         entry.BeginReading(start_iter);
         entry.EndReading(end_iter);
         semicolon_iter = start_iter;
         FindSemicolon(semicolon_iter, end_iter);
         if (semicolon_iter != end_iter) { // we have something resembling a valid entry
           rv = ParseMIMEType(start_iter, majorTypeStart, majorTypeEnd,
                              minorTypeStart, minorTypeEnd, semicolon_iter);
           if (NS_SUCCEEDED(rv) &&
               Substring(majorTypeStart,
                         majorTypeEnd).Equals(aMajorType,
                                              nsCaseInsensitiveStringComparator()) &&
               Substring(minorTypeStart,
                         minorTypeEnd).Equals(aMinorType,
                                              nsCaseInsensitiveStringComparator())) { // we have a match
             bool match = true;
             ++semicolon_iter;             // point at the first char past the semicolon
             start_iter = semicolon_iter;  // handler string starts here
             FindSemicolon(semicolon_iter, end_iter);
             while (start_iter != semicolon_iter &&
                    nsCRT::IsAsciiSpace(*start_iter)) {
               ++start_iter;
             }
             LOG(("The real handler is: '%s'\n",
                  NS_LossyConvertUTF16toASCII(Substring(start_iter,
                                                       semicolon_iter)).get()));
             // XXX ugly hack.  Just grab the executable name
             nsAString::const_iterator end_handler_iter = semicolon_iter;
             nsAString::const_iterator end_executable_iter = start_iter;
             while (end_executable_iter != end_handler_iter &&
                    !nsCRT::IsAsciiSpace(*end_executable_iter)) {
               ++end_executable_iter;
             }
             // XXX End ugly hack
             aHandler = Substring(start_iter, end_executable_iter);
             nsAString::const_iterator start_option_iter, end_optionname_iter, equal_sign_iter;
             bool equalSignFound;
             while (match &&
                    semicolon_iter != end_iter &&
                    ++semicolon_iter != end_iter) { // there are options left and we still match
               start_option_iter = semicolon_iter;
               // skip over leading whitespace
               while (start_option_iter != end_iter &&
                      nsCRT::IsAsciiSpace(*start_option_iter)) {
                 ++start_option_iter;
               }
               if (start_option_iter == end_iter) { // nothing actually here
                 break;
               }
               semicolon_iter = start_option_iter;
               FindSemicolon(semicolon_iter, end_iter);
               equal_sign_iter = start_option_iter;
               equalSignFound = false;
               while (equal_sign_iter != semicolon_iter && !equalSignFound) {
                 switch(*equal_sign_iter) {
                 case '\\':
                   equal_sign_iter.advance(2);
                   break;
                 case '=':
                   equalSignFound = true;
                   break;
                 default:
                   ++equal_sign_iter;
                   break;
                 }
               }
               end_optionname_iter = start_option_iter;
               // find end of option name
               while (end_optionname_iter != equal_sign_iter &&
                      !nsCRT::IsAsciiSpace(*end_optionname_iter)) {
                 ++end_optionname_iter;
               }
               nsDependentSubstring optionName(start_option_iter, end_optionname_iter);
               if (equalSignFound) {
                 // This is an option that has a name and value
                 if (optionName.EqualsLiteral("description")) {
                   aDescription = Substring(++equal_sign_iter, semicolon_iter);
                 } else if (optionName.EqualsLiteral("x-mozilla-flags")) {
                   aMozillaFlags = Substring(++equal_sign_iter, semicolon_iter);
                 } else if (optionName.EqualsLiteral("test")) {
                   nsAutoCString testCommand;
                   rv = UnescapeCommand(Substring(++equal_sign_iter, semicolon_iter),
                                        aMajorType,
                                        aMinorType,
                                        testCommand);
                   if (NS_FAILED(rv))
                     continue;
                   nsCOMPtr<nsIProcess> process = do_CreateInstance(NS_PROCESS_CONTRACTID, &rv);
                   if (NS_FAILED(rv))
                     continue;
                   nsCOMPtr<nsIFile> file(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv));
                   if (NS_FAILED(rv))
                     continue;
                   rv = file->InitWithNativePath(NS_LITERAL_CSTRING("/bin/sh"));
                   if (NS_FAILED(rv))
                     continue;
                   rv = process->Init(file);
                   if (NS_FAILED(rv))
                     continue;
                   const char *args[] = { "-c", testCommand.get() };
                   LOG(("Running Test: %s\n", testCommand.get()));
                   rv = process->Run(true, args, 2);
                   if (NS_FAILED(rv))
                     continue;
                   int32_t exitValue;
                   rv = process->GetExitValue(&exitValue);
                   if (NS_FAILED(rv))
                     continue;
                   LOG(("Exit code: %d\n", exitValue));
                   if (exitValue) {
                     match = false;
                   }
                 }
               } else {
                 // This is an option that just has a name but no value (eg "copiousoutput")
                 if (optionName.EqualsLiteral("needsterminal")) {
                   match = false;
                 }
               }
             }
             if (match) { // we did not fail any test clauses; all is good
               // get out of here
               mailcapFile->Close();
               return NS_OK;
             } else { // pretend that this match never happened
               aDescription.Truncate();
               aMozillaFlags.Truncate();
               aHandler.Truncate();
             }
           }
         }
         // zero out the entry for the next cycle
         entry.Truncate();
       }
     }
     if (!more) {
       rv = NS_ERROR_NOT_AVAILABLE;
       break;
     }
     rv = mailcap->ReadLine(cBuffer, &more);
   } while (NS_SUCCEEDED(rv));
   mailcapFile->Close();
   return rv;
 }
 nsresult nsOSHelperAppService::OSProtocolHandlerExists(const char * aProtocolScheme, bool * aHandlerExists)
 {
   LOG(("-- nsOSHelperAppService::OSProtocolHandlerExists for '%s'\n",
        aProtocolScheme));
   *aHandlerExists = false;
 #if defined(MOZ_ENABLE_CONTENTACTION)
   // libcontentaction requires character ':' after scheme
   ContentAction::Action action =
     ContentAction::Action::defaultActionForScheme(QString(aProtocolScheme) + ':');
   if (action.isValid())
     *aHandlerExists = true;
 #endif
 #ifdef MOZ_WIDGET_GTK
   // Check the GConf registry for a protocol handler
   *aHandlerExists = nsGNOMERegistry::HandlerExists(aProtocolScheme);
 #endif
   return NS_OK;
 }
 NS_IMETHODIMP nsOSHelperAppService::GetApplicationDescription(const nsACString& aScheme, nsAString& _retval)
 {
 #ifdef MOZ_WIDGET_GTK
   nsGNOMERegistry::GetAppDescForScheme(aScheme, _retval);
   return _retval.IsEmpty() ? NS_ERROR_NOT_AVAILABLE : NS_OK;
 #else
   return NS_ERROR_NOT_AVAILABLE;
 #endif
 }
 nsresult nsOSHelperAppService::GetFileTokenForPath(const char16_t * platformAppPath, nsIFile ** aFile)
 {
   LOG(("-- nsOSHelperAppService::GetFileTokenForPath: '%s'\n",
        NS_LossyConvertUTF16toASCII(platformAppPath).get()));
   if (! *platformAppPath) { // empty filename--return error
     NS_WARNING("Empty filename passed in.");
     return NS_ERROR_INVALID_ARG;
   }
   // first check if the base class implementation finds anything
   nsresult rv = nsExternalHelperAppService::GetFileTokenForPath(platformAppPath, aFile);
   if (NS_SUCCEEDED(rv))
     return rv;
   // If the reason for failure was that the file doesn't exist, return too
   // (because it means the path was absolute, and so that we shouldn't search in
   // the path)
   if (rv == NS_ERROR_FILE_NOT_FOUND)
     return rv;
   // If we get here, we really should have a relative path.
   NS_ASSERTION(*platformAppPath != char16_t('/'), "Unexpected absolute path");
   nsCOMPtr<nsIFile> localFile (do_CreateInstance(NS_LOCAL_FILE_CONTRACTID));
   if (!localFile) return NS_ERROR_NOT_INITIALIZED;
   bool exists = false;
   // ugly hack.  Walk the PATH variable...
   char* unixpath = PR_GetEnv("PATH");
   nsAutoCString path(unixpath);
   const char* start_iter = path.BeginReading(start_iter);
   const char* colon_iter = start_iter;
   const char* end_iter = path.EndReading(end_iter);
   while (start_iter != end_iter && !exists) {
     while (colon_iter != end_iter && *colon_iter != ':') {
       ++colon_iter;
     }
     localFile->InitWithNativePath(Substring(start_iter, colon_iter));
     rv = localFile->AppendRelativePath(nsDependentString(platformAppPath));
     // Failing AppendRelativePath is a bad thing - it should basically always
     // succeed given a relative path. Show a warning if it does fail.
     // To prevent infinite loops when it does fail, return at this point.
     NS_ENSURE_SUCCESS(rv, rv);
     localFile->Exists(&exists);
     if (!exists) {
       if (colon_iter == end_iter) {
         break;
       }
       ++colon_iter;
       start_iter = colon_iter;
     }
   }
   if (exists) {
     rv = NS_OK;
   } else {
     rv = NS_ERROR_NOT_AVAILABLE;
   }
   *aFile = localFile;
   NS_IF_ADDREF(*aFile);
   return rv;
 }
 already_AddRefed<nsMIMEInfoBase>
 nsOSHelperAppService::GetFromExtension(const nsCString& aFileExt) {
   // if the extension is empty, return immediately
   if (aFileExt.IsEmpty())
     return nullptr;
   LOG(("Here we do an extension lookup for '%s'\n", aFileExt.get()));
   nsAutoString majorType, minorType,
                mime_types_description, mailcap_description,
                handler, mozillaFlags;
   nsresult rv = LookUpTypeAndDescription(NS_ConvertUTF8toUTF16(aFileExt),
                                          majorType,
                                          minorType,
                                          mime_types_description,
                                          true);
   if (NS_FAILED(rv) || majorType.IsEmpty()) {
 #ifdef MOZ_WIDGET_GTK
     LOG(("Looking in GNOME registry\n"));
     nsRefPtr<nsMIMEInfoBase> gnomeInfo =
       nsGNOMERegistry::GetFromExtension(aFileExt);
     if (gnomeInfo) {
       LOG(("Got MIMEInfo from GNOME registry\n"));
       return gnomeInfo.forget();
     }
 #endif
     rv = LookUpTypeAndDescription(NS_ConvertUTF8toUTF16(aFileExt),
                                   majorType,
                                   minorType,
                                   mime_types_description,
                                   false);
   }
   if (NS_FAILED(rv))
     return nullptr;
   NS_LossyConvertUTF16toASCII asciiMajorType(majorType);
   NS_LossyConvertUTF16toASCII asciiMinorType(minorType);
   LOG(("Type/Description results:  majorType='%s', minorType='%s', description='%s'\n",
           asciiMajorType.get(),
           asciiMinorType.get(),
           NS_LossyConvertUTF16toASCII(mime_types_description).get()));
   if (majorType.IsEmpty() && minorType.IsEmpty()) {
     // we didn't get a type mapping, so we can't do anything useful
     return nullptr;
   }
   nsAutoCString mimeType(asciiMajorType + NS_LITERAL_CSTRING("/") + asciiMinorType);
   nsRefPtr<nsMIMEInfoUnix> mimeInfo = new nsMIMEInfoUnix(mimeType);
   mimeInfo->AppendExtension(aFileExt);
   rv = LookUpHandlerAndDescription(majorType, minorType,
                                    handler, mailcap_description,
                                    mozillaFlags);
   LOG(("Handler/Description results:  handler='%s', description='%s', mozillaFlags='%s'\n",
           NS_LossyConvertUTF16toASCII(handler).get(),
           NS_LossyConvertUTF16toASCII(mailcap_description).get(),
           NS_LossyConvertUTF16toASCII(mozillaFlags).get()));
   mailcap_description.Trim(" \t\"");
   mozillaFlags.Trim(" \t");
   if (!mime_types_description.IsEmpty()) {
     mimeInfo->SetDescription(mime_types_description);
   } else {
     mimeInfo->SetDescription(mailcap_description);
   }
   if (NS_SUCCEEDED(rv) && handler.IsEmpty()) {
     rv = NS_ERROR_NOT_AVAILABLE;
   }
   if (NS_SUCCEEDED(rv)) {
     nsCOMPtr<nsIFile> handlerFile;
     rv = GetFileTokenForPath(handler.get(), getter_AddRefs(handlerFile));
     if (NS_SUCCEEDED(rv)) {
       mimeInfo->SetDefaultApplication(handlerFile);
       mimeInfo->SetPreferredAction(nsIMIMEInfo::useSystemDefault);
       mimeInfo->SetDefaultDescription(handler);
     }
   }
   if (NS_FAILED(rv)) {
     mimeInfo->SetPreferredAction(nsIMIMEInfo::saveToDisk);
   }
   return mimeInfo.forget();
 }
 already_AddRefed<nsMIMEInfoBase>
 nsOSHelperAppService::GetFromType(const nsCString& aMIMEType) {
   // if the type is empty, return immediately
   if (aMIMEType.IsEmpty())
     return nullptr;
   LOG(("Here we do a mimetype lookup for '%s'\n", aMIMEType.get()));
   // extract the major and minor types
   NS_ConvertASCIItoUTF16 mimeType(aMIMEType);
   nsAString::const_iterator start_iter, end_iter,
                             majorTypeStart, majorTypeEnd,
                             minorTypeStart, minorTypeEnd;
   mimeType.BeginReading(start_iter);
   mimeType.EndReading(end_iter);
   // XXX FIXME: add typeOptions parsing in here
   nsresult rv = ParseMIMEType(start_iter, majorTypeStart, majorTypeEnd,
                               minorTypeStart, minorTypeEnd, end_iter);
   if (NS_FAILED(rv)) {
     return nullptr;
   }
   nsDependentSubstring majorType(majorTypeStart, majorTypeEnd);
   nsDependentSubstring minorType(minorTypeStart, minorTypeEnd);
   // First check the user's private mailcap file
   nsAutoString mailcap_description, handler, mozillaFlags;
   DoLookUpHandlerAndDescription(majorType,
                                 minorType,
                                 handler,
                                 mailcap_description,
                                 mozillaFlags,
                                 true);
   LOG(("Private Handler/Description results:  handler='%s', description='%s'\n",
           NS_LossyConvertUTF16toASCII(handler).get(),
           NS_LossyConvertUTF16toASCII(mailcap_description).get()));
 #ifdef MOZ_WIDGET_GTK
   nsRefPtr<nsMIMEInfoBase> gnomeInfo;
   if (handler.IsEmpty()) {
     // No useful data yet.  Check the GNOME registry.  Unfortunately, newer
     // GNOME versions no longer have type-to-extension mappings, so we might
     // get back a MIMEInfo without any extensions set.  In that case we'll have
     // to look in our mime.types files for the extensions.
     LOG(("Looking in GNOME registry\n"));
     gnomeInfo = nsGNOMERegistry::GetFromType(aMIMEType);
     if (gnomeInfo && gnomeInfo->HasExtensions()) {
       LOG(("Got MIMEInfo from GNOME registry, and it has extensions set\n"));
       return gnomeInfo.forget();
     }
   }
 #endif
   // Now look up our extensions
   nsAutoString extensions, mime_types_description;
   LookUpExtensionsAndDescription(majorType,
                                  minorType,
                                  extensions,
                                  mime_types_description);
 #ifdef MOZ_WIDGET_GTK
   if (gnomeInfo) {
     LOG(("Got MIMEInfo from GNOME registry without extensions; setting them "
          "to %s\n", NS_LossyConvertUTF16toASCII(extensions).get()));
     NS_ASSERTION(!gnomeInfo->HasExtensions(), "How'd that happen?");
     gnomeInfo->SetFileExtensions(NS_ConvertUTF16toUTF8(extensions));
     return gnomeInfo.forget();
   }
 #endif
   if (handler.IsEmpty()) {
     DoLookUpHandlerAndDescription(majorType,
                                   minorType,
                                   handler,
                                   mailcap_description,
                                   mozillaFlags,
                                   false);
   }
   if (handler.IsEmpty()) {
     DoLookUpHandlerAndDescription(majorType,
                                   NS_LITERAL_STRING("*"),
                                   handler,
                                   mailcap_description,
                                   mozillaFlags,
                                   true);
   }
   if (handler.IsEmpty()) {
     DoLookUpHandlerAndDescription(majorType,
                                   NS_LITERAL_STRING("*"),
                                   handler,
                                   mailcap_description,
                                   mozillaFlags,
                                   false);
   }
   LOG(("Handler/Description results:  handler='%s', description='%s', mozillaFlags='%s'\n",
           NS_LossyConvertUTF16toASCII(handler).get(),
           NS_LossyConvertUTF16toASCII(mailcap_description).get(),
           NS_LossyConvertUTF16toASCII(mozillaFlags).get()));
   mailcap_description.Trim(" \t\"");
   mozillaFlags.Trim(" \t");
   if (handler.IsEmpty() && extensions.IsEmpty() &&
       mailcap_description.IsEmpty() && mime_types_description.IsEmpty()) {
     // No real useful info
     return nullptr;
   }
   nsRefPtr<nsMIMEInfoUnix> mimeInfo = new nsMIMEInfoUnix(aMIMEType);
   mimeInfo->SetFileExtensions(NS_ConvertUTF16toUTF8(extensions));
   if (! mime_types_description.IsEmpty()) {
     mimeInfo->SetDescription(mime_types_description);
   } else {
     mimeInfo->SetDescription(mailcap_description);
   }
   rv = NS_ERROR_NOT_AVAILABLE;
   nsCOMPtr<nsIFile> handlerFile;
   if (!handler.IsEmpty()) {
     rv = GetFileTokenForPath(handler.get(), getter_AddRefs(handlerFile));
   }
   if (NS_SUCCEEDED(rv)) {
     mimeInfo->SetDefaultApplication(handlerFile);
     mimeInfo->SetPreferredAction(nsIMIMEInfo::useSystemDefault);
     mimeInfo->SetDefaultDescription(handler);
   } else {
     mimeInfo->SetPreferredAction(nsIMIMEInfo::saveToDisk);
   }
   return mimeInfo.forget();
 }
 already_AddRefed<nsIMIMEInfo>
 nsOSHelperAppService::GetMIMEInfoFromOS(const nsACString& aType,
                                         const nsACString& aFileExt,
                                         bool       *aFound) {
   *aFound = true;
   nsRefPtr<nsMIMEInfoBase> retval = GetFromType(PromiseFlatCString(aType));
   bool hasDefault = false;
   if (retval)
     retval->GetHasDefaultHandler(&hasDefault);
   if (!retval || !hasDefault) {
     nsRefPtr<nsMIMEInfoBase> miByExt = GetFromExtension(PromiseFlatCString(aFileExt));
     // If we had no extension match, but a type match, use that
     if (!miByExt && retval)
       return retval.forget();
     // If we had an extension match but no type match, set the mimetype and use
     // it
     if (!retval && miByExt) {
       if (!aType.IsEmpty())
         miByExt->SetMIMEType(aType);
       miByExt.swap(retval);
       return retval.forget();
     }
     // If we got nothing, make a new mimeinfo
     if (!retval) {
       *aFound = false;
       retval = new nsMIMEInfoUnix(aType);
       if (retval) {
         if (!aFileExt.IsEmpty())
           retval->AppendExtension(aFileExt);
       }
       return retval.forget();
     }
     // Copy the attributes of retval (mimeinfo from type) onto miByExt, to
     // return it
     // but reset to just collected mDefaultAppDescription (from ext)
     nsAutoString byExtDefault;
     miByExt->GetDefaultDescription(byExtDefault);
     retval->SetDefaultDescription(byExtDefault);
     retval->CopyBasicDataTo(miByExt);
     miByExt.swap(retval);
   }
   return retval.forget();
 }
 NS_IMETHODIMP
 nsOSHelperAppService::GetProtocolHandlerInfoFromOS(const nsACString &aScheme,
                                                    bool *found,
                                                    nsIHandlerInfo **_retval)
 {
   NS_ASSERTION(!aScheme.IsEmpty(), "No scheme was specified!");
   // We must check that a registered handler exists so that gnome_url_show
   // doesn't fallback to gnomevfs.
   // See nsGNOMERegistry::LoadURL and bug 389632.
   nsresult rv = OSProtocolHandlerExists(nsPromiseFlatCString(aScheme).get(),
                                         found);
   if (NS_FAILED(rv))
     return rv;
   nsMIMEInfoUnix *handlerInfo =
     new nsMIMEInfoUnix(aScheme, nsMIMEInfoBase::eProtocolInfo);
   NS_ENSURE_TRUE(handlerInfo, NS_ERROR_OUT_OF_MEMORY);
   NS_ADDREF(*_retval = handlerInfo);
   if (!*found) {
     // Code that calls this requires an object regardless if the OS has
     // something for us, so we return the empty object.
     return NS_OK;
   }
   nsAutoString desc;
   GetApplicationDescription(aScheme, desc);
   handlerInfo->SetDefaultDescription(desc);
   return NS_OK;
 }

The Tor Browser / annotate

uriloader/exthandler/unix/nsOSHelperAppService.cpp@6474c204b198 (annotated)

uriloader/exthandler/unix/nsOSHelperAppService.cpp