/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-

 * vim:expandtab:shiftwidth=2:tabstop=2:cin:

 * 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 "base/basictypes.h"

/* This must occur *after* base/basictypes.h to avoid typedefs conflicts. */

#include "mozilla/ArrayUtils.h"

#include "mozilla/Base64.h"

#include "mozilla/ResultExtensions.h"

#include "mozilla/dom/ContentChild.h"

#include "mozilla/dom/TabChild.h"

#include "nsXULAppAPI.h"

#include "nsExternalHelperAppService.h"

#include "nsCExternalHandlerService.h"

#include "nsIURI.h"

#include "nsIURL.h"

#include "nsIFile.h"

#include "nsIFileURL.h"

#include "nsIChannel.h"

#include "nsIDirectoryService.h"

#include "nsAppDirectoryServiceDefs.h"

#include "nsICategoryManager.h"

#include "nsDependentSubstring.h"

#include "nsString.h"

#include "nsUnicharUtils.h"

#include "nsIStringEnumerator.h"

#include "nsMemory.h"

#include "nsIStreamListener.h"

#include "nsIMIMEService.h"

#include "nsILoadGroup.h"

#include "nsIWebProgressListener.h"

#include "nsITransfer.h"

#include "nsReadableUtils.h"

#include "nsIRequest.h"

#include "nsDirectoryServiceDefs.h"

#include "nsIInterfaceRequestor.h"

#include "nsThreadUtils.h"

#include "nsAutoPtr.h"

#include "nsIMutableArray.h"

#include "nsIRedirectHistoryEntry.h"

// used to access our datastore of user-configured helper applications

#include "nsIHandlerService.h"

#include "nsIMIMEInfo.h"

#include "nsIRefreshURI.h" // XXX needed to redirect according to Refresh: URI

#include "nsIDocumentLoader.h" // XXX needed to get orig. channel and assoc. refresh uri

#include "nsIHelperAppLauncherDialog.h"

#include "nsIContentDispatchChooser.h"

#include "nsNetUtil.h"

#include "nsIPrivateBrowsingChannel.h"

#include "nsIIOService.h"

#include "nsNetCID.h"

#include "nsDSURIContentListener.h"

#include "nsMimeTypes.h"

// used for header disposition information.

#include "nsIHttpChannel.h"

#include "nsIHttpChannelInternal.h"

#include "nsIEncodedChannel.h"

#include "nsIMultiPartChannel.h"

#include "nsIFileChannel.h"

#include "nsIObserverService.h" // so we can be a profile change observer

#include "nsIPropertyBag2.h" // for the 64-bit content length

#ifdef XP_MACOSX

#include "nsILocalFileMac.h"

#endif

#include "nsIPluginHost.h" // XXX needed for ext->type mapping (bug 233289)

#include "nsPluginHost.h"

#include "nsEscape.h"

#include "nsIStringBundle.h" // XXX needed to localize error msgs

#include "nsIPrompt.h"

#include "nsITextToSubURI.h" // to unescape the filename

#include "nsIMIMEHeaderParam.h"

#include "nsIWindowWatcher.h"

#include "nsDocShellCID.h"

#include "nsCRT.h"

#include "nsLocalHandlerApp.h"

#include "nsIRandomGenerator.h"

#include "ContentChild.h"

#include "nsXULAppAPI.h"

#include "nsPIDOMWindow.h"

#include "nsIDocShellTreeOwner.h"

#include "nsIDocShellTreeItem.h"

#include "ExternalHelperAppChild.h"

#ifdef XP_WIN

#include "nsWindowsHelpers.h"

#endif

#ifdef MOZ_WIDGET_ANDROID

#include "FennecJNIWrappers.h"

#endif

#include "mozilla/Preferences.h"

#include "mozilla/ipc/URIUtils.h"

using namespace mozilla;

using namespace mozilla::ipc;

// Download Folder location constants

#define NS_PREF_DOWNLOAD_DIR        "browser.download.dir"

#define NS_PREF_DOWNLOAD_FOLDERLIST "browser.download.folderList"

enum {

  NS_FOLDER_VALUE_DESKTOP = 0

, NS_FOLDER_VALUE_DOWNLOADS = 1

, NS_FOLDER_VALUE_CUSTOM = 2

};

LazyLogModule nsExternalHelperAppService::mLog("HelperAppService");

// Using level 3 here because the OSHelperAppServices use a log level

// of LogLevel::Debug (4), and we want less detailed output here

// Using 3 instead of LogLevel::Warning because we don't output warnings

#undef LOG

#define LOG(args) MOZ_LOG(nsExternalHelperAppService::mLog, mozilla::LogLevel::Info, args)

#define LOG_ENABLED() MOZ_LOG_TEST(nsExternalHelperAppService::mLog, mozilla::LogLevel::Info)

static const char NEVER_ASK_FOR_SAVE_TO_DISK_PREF[] =

  "browser.helperApps.neverAsk.saveToDisk";

static const char NEVER_ASK_FOR_OPEN_FILE_PREF[] =

  "browser.helperApps.neverAsk.openFile";

// Helper functions for Content-Disposition headers

/**

 * Given a URI fragment, unescape it

 * @param aFragment The string to unescape

 * @param aURI The URI from which this fragment is taken. Only its character set

 *             will be used.

 * @param aResult [out] Unescaped string.

 */

static nsresult UnescapeFragment(const nsACString& aFragment, nsIURI* aURI,

                                 nsAString& aResult)

{

  // We need the unescaper

  nsresult rv;

  nsCOMPtr<nsITextToSubURI> textToSubURI = do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv);

  NS_ENSURE_SUCCESS(rv, rv);

  return textToSubURI->UnEscapeURIForUI(NS_LITERAL_CSTRING("UTF-8"), aFragment, aResult);

}

/**

 * UTF-8 version of UnescapeFragment.

 * @param aFragment The string to unescape

 * @param aURI The URI from which this fragment is taken. Only its character set

 *             will be used.

 * @param aResult [out] Unescaped string, UTF-8 encoded.

 * @note It is safe to pass the same string for aFragment and aResult.

 * @note When this function fails, aResult will not be modified.

 */

static nsresult UnescapeFragment(const nsACString& aFragment, nsIURI* aURI,

                                 nsACString& aResult)

{

  nsAutoString result;

  nsresult rv = UnescapeFragment(aFragment, aURI, result);

  if (NS_SUCCEEDED(rv))

    CopyUTF16toUTF8(result, aResult);

  return rv;

}

/**

 * Given a channel, returns the filename and extension the channel has.

 * This uses the URL and other sources (nsIMultiPartChannel).

 * Also gives back whether the channel requested external handling (i.e.

 * whether Content-Disposition: attachment was sent)

 * @param aChannel The channel to extract the filename/extension from

 * @param aFileName [out] Reference to the string where the filename should be

 *        stored. Empty if it could not be retrieved.

 *        WARNING - this filename may contain characters which the OS does not

 *        allow as part of filenames!

 * @param aExtension [out] Reference to the string where the extension should

 *        be stored. Empty if it could not be retrieved. Stored in UTF-8.

 * @param aAllowURLExtension (optional) Get the extension from the URL if no

 *        Content-Disposition header is present. Default is true.

 * @retval true The server sent Content-Disposition:attachment or equivalent

 * @retval false Content-Disposition: inline or no content-disposition header

 *         was sent.

 */

static bool GetFilenameAndExtensionFromChannel(nsIChannel* aChannel,

                                                 nsString& aFileName,

                                                 nsCString& aExtension,

                                                 bool aAllowURLExtension = true)

{

  aExtension.Truncate();

  /*

   * If the channel is an http or part of a multipart channel and we

   * have a content disposition header set, then use the file name

   * suggested there as the preferred file name to SUGGEST to the

   * user.  we shouldn't actually use that without their

   * permission... otherwise just use our temp file

   */

  bool handleExternally = false;

  uint32_t disp;

  nsresult rv = aChannel->GetContentDisposition(&disp);

  if (NS_SUCCEEDED(rv))

  {

    aChannel->GetContentDispositionFilename(aFileName);

    if (disp == nsIChannel::DISPOSITION_ATTACHMENT)

      handleExternally = true;

  }

  // If the disposition header didn't work, try the filename from nsIURL

  nsCOMPtr<nsIURI> uri;

  aChannel->GetURI(getter_AddRefs(uri));

  nsCOMPtr<nsIURL> url(do_QueryInterface(uri));

  if (url && aFileName.IsEmpty())

  {

    if (aAllowURLExtension) {

      url->GetFileExtension(aExtension);

      UnescapeFragment(aExtension, url, aExtension);

      // Windows ignores terminating dots. So we have to as well, so

      // that our security checks do "the right thing"

      // In case the aExtension consisted only of the dot, the code below will

      // extract an aExtension from the filename

      aExtension.Trim(".", false);

    }

    // try to extract the file name from the url and use that as a first pass as the

    // leaf name of our temp file...

    nsAutoCString leafName;

    url->GetFileName(leafName);

    if (!leafName.IsEmpty())

    {

      rv = UnescapeFragment(leafName, url, aFileName);

      if (NS_FAILED(rv))

      {

        CopyUTF8toUTF16(leafName, aFileName); // use escaped name

      }

    }

  }

  // Extract Extension, if we have a filename; otherwise,

  // truncate the string

  if (aExtension.IsEmpty()) {

    if (!aFileName.IsEmpty())

    {

      // Windows ignores terminating dots. So we have to as well, so

      // that our security checks do "the right thing"

      aFileName.Trim(".", false);

      // XXX RFindCharInReadable!!

      nsAutoString fileNameStr(aFileName);

      int32_t idx = fileNameStr.RFindChar(char16_t('.'));

      if (idx != kNotFound)

        CopyUTF16toUTF8(StringTail(fileNameStr, fileNameStr.Length() - idx - 1), aExtension);

    }

  }

  return handleExternally;

}

/**

 * Obtains the directory to use.  This tends to vary per platform, and

 * needs to be consistent throughout our codepaths. For platforms where

 * helper apps use the downloads directory, this should be kept in

 * sync with DownloadIntegration.jsm.

 *

 * Optionally skip availability of the directory and storage.

 */

static nsresult GetDownloadDirectory(nsIFile **_directory,

                                     bool aSkipChecks = false)

{

  nsCOMPtr<nsIFile> dir;

#ifdef XP_MACOSX

  // On OS X, we first try to get the users download location, if it's set.

  switch (Preferences::GetInt(NS_PREF_DOWNLOAD_FOLDERLIST, -1)) {

    case NS_FOLDER_VALUE_DESKTOP:

      (void) NS_GetSpecialDirectory(NS_OS_DESKTOP_DIR, getter_AddRefs(dir));

      break;

    case NS_FOLDER_VALUE_CUSTOM:

      {

        Preferences::GetComplex(NS_PREF_DOWNLOAD_DIR,

                                NS_GET_IID(nsIFile),

                                getter_AddRefs(dir));

        if (!dir) break;

        // If we're not checking for availability we're done.

        if (aSkipChecks) {

          dir.forget(_directory);

          return NS_OK;

        }

        // We have the directory, and now we need to make sure it exists

        bool dirExists = false;

        (void) dir->Exists(&dirExists);

        if (dirExists) break;

        nsresult rv = dir->Create(nsIFile::DIRECTORY_TYPE, 0755);

        if (NS_FAILED(rv)) {

          dir = nullptr;

          break;

        }

      }

      break;

    case NS_FOLDER_VALUE_DOWNLOADS:

      // This is just the OS default location, so fall out

      break;

  }

  if (!dir) {

    // If not, we default to the OS X default download location.

    nsresult rv = NS_GetSpecialDirectory(NS_OSX_DEFAULT_DOWNLOAD_DIR,

                                         getter_AddRefs(dir));

    NS_ENSURE_SUCCESS(rv, rv);

  }

#elif defined(ANDROID)

  // We ask Java for the temporary download directory. The directory will be

  // different depending on whether we have the permission to write to the

  // public download directory or not.

  // In the case where we do not have the permission we will start the

  // download to the app cache directory and later move it to the final

  // destination after prompting for the permission.

  jni::String::LocalRef downloadDir;

  if (jni::IsFennec()) {

    downloadDir = java::DownloadsIntegration::GetTemporaryDownloadDirectory();

  }

  nsresult rv;

  if (downloadDir) {

    nsCOMPtr<nsIFile> ldir;

    rv = NS_NewNativeLocalFile(downloadDir->ToCString(),

                               true, getter_AddRefs(ldir));

    NS_ENSURE_SUCCESS(rv, rv);

    dir = do_QueryInterface(ldir);

    // If we're not checking for availability we're done.

    if (aSkipChecks) {

      dir.forget(_directory);

      return NS_OK;

    }

  }

  else {

    return NS_ERROR_FAILURE;

  }

#else

  // On all other platforms, we default to the systems temporary directory.

  nsresult rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(dir));

  NS_ENSURE_SUCCESS(rv, rv);

#if defined(XP_UNIX)

  // Ensuring that only the current user can read the file names we end up

  // creating. Note that Creating directories with specified permission only

  // supported on Unix platform right now. That's why above if exists.

  uint32_t permissions;

  rv = dir->GetPermissions(&permissions);

  NS_ENSURE_SUCCESS(rv, rv);

  if (permissions != PR_IRWXU) {

    const char* userName = PR_GetEnv("USERNAME");

    if (!userName || !*userName) {

      userName = PR_GetEnv("USER");

    }

    if (!userName || !*userName) {

      userName = PR_GetEnv("LOGNAME");

    }

    if (!userName || !*userName) {

      userName = "mozillaUser";

    }

    nsAutoString userDir;

    userDir.AssignLiteral("mozilla_");

    userDir.AppendASCII(userName);

    userDir.ReplaceChar(FILE_PATH_SEPARATOR FILE_ILLEGAL_CHARACTERS, '_');

    int counter = 0;

    bool pathExists;

    nsCOMPtr<nsIFile> finalPath;

    while (true) {

      nsAutoString countedUserDir(userDir);

      countedUserDir.AppendInt(counter, 10);

      dir->Clone(getter_AddRefs(finalPath));

      finalPath->Append(countedUserDir);

      rv = finalPath->Exists(&pathExists);

      NS_ENSURE_SUCCESS(rv, rv);

      if (pathExists) {

        // If this path has the right permissions, use it.

        rv = finalPath->GetPermissions(&permissions);

        NS_ENSURE_SUCCESS(rv, rv);

        // Ensuring the path is writable by the current user.

        bool isWritable;

        rv = finalPath->IsWritable(&isWritable);

        NS_ENSURE_SUCCESS(rv, rv);

        if (permissions == PR_IRWXU && isWritable) {

          dir = finalPath;

          break;

        }

      }

      rv = finalPath->Create(nsIFile::DIRECTORY_TYPE, PR_IRWXU);

      if (NS_SUCCEEDED(rv)) {

        dir = finalPath;

        break;

      }

      else if (rv != NS_ERROR_FILE_ALREADY_EXISTS) {

        // Unexpected error.

        return rv;

      }

      counter++;

    }

  }

#endif

#endif

  NS_ASSERTION(dir, "Somehow we didn't get a download directory!");

  dir.forget(_directory);

  return NS_OK;

}

/**

 * Structure for storing extension->type mappings.

 * @see defaultMimeEntries

 */

struct nsDefaultMimeTypeEntry {

  const char* mMimeType;

  const char* mFileExtension;

};

/**

 * Default extension->mimetype mappings. These are not overridable.

 * If you add types here, make sure they are lowercase, or you'll regret it.

 */

static const nsDefaultMimeTypeEntry defaultMimeEntries[] =

{

  // The following are those extensions that we're asked about during startup,

  // sorted by order used

  { IMAGE_GIF, "gif" },

  { TEXT_XML, "xml" },

  { APPLICATION_RDF, "rdf" },

  { TEXT_XUL, "xul" },

  { IMAGE_PNG, "png" },

  // -- end extensions used during startup

  { TEXT_CSS, "css" },

  { IMAGE_JPEG, "jpeg" },

  { IMAGE_JPEG, "jpg" },

  { IMAGE_SVG_XML, "svg" },

  { TEXT_HTML, "html" },

  { TEXT_HTML, "htm" },

  { APPLICATION_XPINSTALL, "xpi" },

  { "application/xhtml+xml", "xhtml" },

  { "application/xhtml+xml", "xht" },

  { TEXT_PLAIN, "txt" },

  { APPLICATION_JSON, "json" },

  { APPLICATION_XJAVASCRIPT, "js" },

  { APPLICATION_XJAVASCRIPT, "jsm" },

  { VIDEO_OGG, "ogv" },

  { VIDEO_OGG, "ogg" },

  { APPLICATION_OGG, "ogg" },

  { AUDIO_OGG, "oga" },

  { AUDIO_OGG, "opus" },

  { APPLICATION_PDF, "pdf" },

  { VIDEO_WEBM, "webm" },

  { AUDIO_WEBM, "webm" },

  { IMAGE_ICO, "ico" },

  { TEXT_PLAIN, "properties" },

  { TEXT_PLAIN, "locale" },

  { TEXT_PLAIN, "ftl" },

#if defined(MOZ_WMF)

  { VIDEO_MP4, "mp4" },

  { AUDIO_MP4, "m4a" },

  { AUDIO_MP3, "mp3" },

#endif

#ifdef MOZ_RAW

  { VIDEO_RAW, "yuv" }

#endif

};

/**

 * This is a small private struct used to help us initialize some

 * default mime types.

 */

struct nsExtraMimeTypeEntry {

  const char* mMimeType; 

  const char* mFileExtensions;

  const char* mDescription;

};

#ifdef XP_MACOSX

#define MAC_TYPE(x) x

#else

#define MAC_TYPE(x) 0

#endif

/**

 * This table lists all of the 'extra' content types that we can deduce from particular

 * file extensions.  These entries also ensure that we provide a good descriptive name

 * when we encounter files with these content types and/or extensions.  These can be

 * overridden by user helper app prefs.

 * If you add types here, make sure they are lowercase, or you'll regret it.

 */

static const nsExtraMimeTypeEntry extraMimeEntries[] =

{

#if defined(XP_MACOSX) // don't define .bin on the mac...use internet config to look that up...

  { APPLICATION_OCTET_STREAM, "exe,com", "Binary File" },

#else

  { APPLICATION_OCTET_STREAM, "exe,com,bin", "Binary File" },

#endif

  { APPLICATION_GZIP2, "gz", "gzip" },

  { "application/x-arj", "arj", "ARJ file" },

  { "application/rtf", "rtf", "Rich Text Format File" },

  { APPLICATION_XPINSTALL, "xpi", "XPInstall Install" },

  { APPLICATION_PDF, "pdf", "Portable Document Format" },

  { APPLICATION_POSTSCRIPT, "ps,eps,ai", "Postscript File" },

  { APPLICATION_XJAVASCRIPT, "js", "Javascript Source File" },

  { APPLICATION_XJAVASCRIPT, "jsm", "Javascript Module Source File" },

#ifdef MOZ_WIDGET_ANDROID

  { "application/vnd.android.package-archive", "apk", "Android Package" },

#endif

  { IMAGE_ART, "art", "ART Image" },

  { IMAGE_BMP, "bmp", "BMP Image" },

  { IMAGE_GIF, "gif", "GIF Image" },

  { IMAGE_ICO, "ico,cur", "ICO Image" },

  { IMAGE_JPEG, "jpeg,jpg,jfif,pjpeg,pjp", "JPEG Image" },

  { IMAGE_PNG, "png", "PNG Image" },

  { IMAGE_APNG, "apng", "APNG Image" },

  { IMAGE_TIFF, "tiff,tif", "TIFF Image" },

  { IMAGE_XBM, "xbm", "XBM Image" },

  { IMAGE_SVG_XML, "svg", "Scalable Vector Graphics" },

  { IMAGE_WEBP, "webp", "WebP Image" },

  { MESSAGE_RFC822, "eml", "RFC-822 data" },

  { TEXT_PLAIN, "txt,text", "Text File" },

  { APPLICATION_JSON, "json", "JavaScript Object Notation" },

  { TEXT_VTT, "vtt", "Web Video Text Tracks" },

  { TEXT_CACHE_MANIFEST, "appcache", "Application Cache Manifest" },

  { TEXT_HTML, "html,htm,shtml,ehtml", "HyperText Markup Language" },

  { "application/xhtml+xml", "xhtml,xht", "Extensible HyperText Markup Language" },

  { APPLICATION_MATHML_XML, "mml", "Mathematical Markup Language" },

  { APPLICATION_RDF, "rdf", "Resource Description Framework" },

  { TEXT_XUL, "xul", "XML-Based User Interface Language" },

  { TEXT_XML, "xml,xsl,xbl", "Extensible Markup Language" },

  { TEXT_CSS, "css", "Style Sheet" },

  { TEXT_VCARD, "vcf,vcard", "Contact Information" },

  { VIDEO_OGG, "ogv", "Ogg Video" },

  { VIDEO_OGG, "ogg", "Ogg Video" },

  { APPLICATION_OGG, "ogg", "Ogg Video"},

  { AUDIO_OGG, "oga", "Ogg Audio" },

  { AUDIO_OGG, "opus", "Opus Audio" },

  { VIDEO_WEBM, "webm", "Web Media Video" },

  { AUDIO_WEBM, "webm", "Web Media Audio" },

  { AUDIO_MP3, "mp3", "MPEG Audio" },

  { VIDEO_MP4, "mp4", "MPEG-4 Video" },

  { AUDIO_MP4, "m4a", "MPEG-4 Audio" },

  { VIDEO_RAW, "yuv", "Raw YUV Video" },

  { AUDIO_WAV, "wav", "Waveform Audio" },

  { VIDEO_3GPP, "3gpp,3gp", "3GPP Video" },

  { VIDEO_3GPP2,"3g2", "3GPP2 Video" },

  { AUDIO_MIDI, "mid", "Standard MIDI Audio" }

};

#undef MAC_TYPE

/**

 * File extensions for which decoding should be disabled.

 * NOTE: These MUST be lower-case and ASCII.

 */

static const nsDefaultMimeTypeEntry nonDecodableExtensions[] = {

  { APPLICATION_GZIP, "gz" }, 

  { APPLICATION_GZIP, "tgz" },

  { APPLICATION_ZIP, "zip" },

  { APPLICATION_COMPRESS, "z" },

  { APPLICATION_GZIP, "svgz" }

};

NS_IMPL_ISUPPORTS(

  nsExternalHelperAppService,

  nsIExternalHelperAppService,

  nsPIExternalAppLauncher,

  nsIExternalProtocolService,

  nsIMIMEService,

  nsIObserver,

  nsISupportsWeakReference)

nsExternalHelperAppService::nsExternalHelperAppService()

{

}

nsresult nsExternalHelperAppService::Init()

{

  // Add an observer for profile change

  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();

  if (!obs)

    return NS_ERROR_FAILURE;

  nsresult rv = obs->AddObserver(this, "profile-before-change", true);

  NS_ENSURE_SUCCESS(rv, rv);

  return obs->AddObserver(this, "last-pb-context-exited", true);

}

nsExternalHelperAppService::~nsExternalHelperAppService()

{

}

nsresult

nsExternalHelperAppService::DoContentContentProcessHelper(const nsACString& aMimeContentType,

                                                          nsIRequest *aRequest,

                                                          nsIInterfaceRequestor *aContentContext,

                                                          bool aForceSave,

                                                          nsIInterfaceRequestor *aWindowContext,

                                                          nsIStreamListener ** aStreamListener)

{

  nsCOMPtr<nsPIDOMWindowOuter> window = do_GetInterface(aContentContext);

  NS_ENSURE_STATE(window);

  // We need to get a hold of a ContentChild so that we can begin forwarding

  // this data to the parent.  In the HTTP case, this is unfortunate, since

  // we're actually passing data from parent->child->parent wastefully, but

  // the Right Fix will eventually be to short-circuit those channels on the

  // parent side based on some sort of subscription concept.

  using mozilla::dom::ContentChild;

  using mozilla::dom::ExternalHelperAppChild;

  ContentChild *child = ContentChild::GetSingleton();

  if (!child) {

    return NS_ERROR_FAILURE;

  }

  nsCString disp;

  nsCOMPtr<nsIURI> uri;

  int64_t contentLength = -1;

  bool wasFileChannel = false;

  uint32_t contentDisposition = -1;

  nsAutoString fileName;

  nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);

  if (channel) {

    channel->GetURI(getter_AddRefs(uri));

    channel->GetContentLength(&contentLength);

    channel->GetContentDisposition(&contentDisposition);

    channel->GetContentDispositionFilename(fileName);

    channel->GetContentDispositionHeader(disp);

    nsCOMPtr<nsIFileChannel> fileChan(do_QueryInterface(aRequest));

    wasFileChannel = fileChan != nullptr;

  }

  nsCOMPtr<nsIURI> referrer;

  NS_GetReferrerFromChannel(channel, getter_AddRefs(referrer));

  OptionalURIParams uriParams, referrerParams;

  SerializeURI(uri, uriParams);

  SerializeURI(referrer, referrerParams);

  // Now we build a protocol for forwarding our data to the parent.  The

  // protocol will act as a listener on the child-side and create a "real"

  // helperAppService listener on the parent-side, via another call to

  // DoContent.

  mozilla::dom::PExternalHelperAppChild *pc =

    child->SendPExternalHelperAppConstructor(uriParams,

                                              nsCString(aMimeContentType),

                                              disp, contentDisposition,

                                              fileName, aForceSave,

                                              contentLength, wasFileChannel,

                                              referrerParams,

                                              mozilla::dom::TabChild::GetFrom(window));

  ExternalHelperAppChild *childListener = static_cast<ExternalHelperAppChild *>(pc);

  NS_ADDREF(*aStreamListener = childListener);

  uint32_t reason = nsIHelperAppLauncherDialog::REASON_CANTHANDLE;

  RefPtr<nsExternalAppHandler> handler =

    new nsExternalAppHandler(nullptr, EmptyCString(), aContentContext, aWindowContext, this,

                             fileName, reason, aForceSave);

  if (!handler) {

    return NS_ERROR_OUT_OF_MEMORY;

  }

  childListener->SetHandler(handler);

  return NS_OK;

}

NS_IMETHODIMP nsExternalHelperAppService::DoContent(const nsACString& aMimeContentType,

                                                    nsIRequest *aRequest,

                                                    nsIInterfaceRequestor *aContentContext,

                                                    bool aForceSave,

                                                    nsIInterfaceRequestor *aWindowContext,

                                                    nsIStreamListener ** aStreamListener)

{

  if (XRE_IsContentProcess()) {

    return DoContentContentProcessHelper(aMimeContentType, aRequest, aContentContext,

                                         aForceSave, aWindowContext, aStreamListener);

  }

  nsAutoString fileName;

  nsAutoCString fileExtension;

  uint32_t reason = nsIHelperAppLauncherDialog::REASON_CANTHANDLE;

  uint32_t contentDisposition = -1;

  // Get the file extension and name that we will need later

  nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);

  nsCOMPtr<nsIURI> uri;

  int64_t contentLength = -1;

  if (channel) {

    channel->GetURI(getter_AddRefs(uri));

    channel->GetContentLength(&contentLength);

    channel->GetContentDisposition(&contentDisposition);

    channel->GetContentDispositionFilename(fileName);

    // Check if we have a POST request, in which case we don't want to use

    // the url's extension

    bool allowURLExt = true;

    nsCOMPtr<nsIHttpChannel> httpChan = do_QueryInterface(channel);

    if (httpChan) {

      nsAutoCString requestMethod;

      Unused << httpChan->GetRequestMethod(requestMethod);

      allowURLExt = !requestMethod.EqualsLiteral("POST");

    }

    // Check if we had a query string - we don't want to check the URL

    // extension if a query is present in the URI

    // If we already know we don't want to check the URL extension, don't

    // bother checking the query

    if (uri && allowURLExt) {

      nsCOMPtr<nsIURL> url = do_QueryInterface(uri);

      if (url) {

        nsAutoCString query;

        // We only care about the query for HTTP and HTTPS URLs

        nsresult rv;

        bool isHTTP, isHTTPS;

        rv = uri->SchemeIs("http", &isHTTP);

        if (NS_FAILED(rv)) {

          isHTTP = false;

        }

        rv = uri->SchemeIs("https", &isHTTPS);

        if (NS_FAILED(rv)) {

          isHTTPS = false;

        }

        if (isHTTP || isHTTPS) {

          url->GetQuery(query);

        }

        // Only get the extension if the query is empty; if it isn't, then the

        // extension likely belongs to a cgi script and isn't helpful

        allowURLExt = query.IsEmpty();

      }

    }

    // Extract name & extension

    bool isAttachment = GetFilenameAndExtensionFromChannel(channel, fileName,

                                                             fileExtension,

                                                             allowURLExt);

    LOG(("Found extension '%s' (filename is '%s', handling attachment: %i)",

         fileExtension.get(), NS_ConvertUTF16toUTF8(fileName).get(),

         isAttachment));

    if (isAttachment) {

      reason = nsIHelperAppLauncherDialog::REASON_SERVERREQUEST;

    }

  }

  LOG(("HelperAppService::DoContent: mime '%s', extension '%s'\n",

       PromiseFlatCString(aMimeContentType).get(), fileExtension.get()));

  // We get the mime service here even though we're the default implementation

  // of it, so it's possible to override only the mime service and not need to

  // reimplement the whole external helper app service itself.

  nsCOMPtr<nsIMIMEService> mimeSvc(do_GetService(NS_MIMESERVICE_CONTRACTID));

  NS_ENSURE_TRUE(mimeSvc, NS_ERROR_FAILURE);

  // Try to find a mime object by looking at the mime type/extension

  nsCOMPtr<nsIMIMEInfo> mimeInfo;

  if (aMimeContentType.Equals(APPLICATION_GUESS_FROM_EXT, nsCaseInsensitiveCStringComparator())) {

    nsAutoCString mimeType;

    if (!fileExtension.IsEmpty()) {

      mimeSvc->GetFromTypeAndExtension(EmptyCString(), fileExtension, getter_AddRefs(mimeInfo));

      if (mimeInfo) {

        mimeInfo->GetMIMEType(mimeType);

        LOG(("OS-Provided mime type '%s' for extension '%s'\n", 

             mimeType.get(), fileExtension.get()));

      }

    }

    if (fileExtension.IsEmpty() || mimeType.IsEmpty()) {

      // Extension lookup gave us no useful match

      mimeSvc->GetFromTypeAndExtension(NS_LITERAL_CSTRING(APPLICATION_OCTET_STREAM), fileExtension,

                                       getter_AddRefs(mimeInfo));

      mimeType.AssignLiteral(APPLICATION_OCTET_STREAM);

    }

    if (channel) {

      channel->SetContentType(mimeType);

    }

    // Don't overwrite SERVERREQUEST

    if (reason == nsIHelperAppLauncherDialog::REASON_CANTHANDLE) {

      reason = nsIHelperAppLauncherDialog::REASON_TYPESNIFFED;

    }

  } else {

    mimeSvc->GetFromTypeAndExtension(aMimeContentType, fileExtension,

                                     getter_AddRefs(mimeInfo));

  } 

  LOG(("Type/Ext lookup found 0x%p\n", mimeInfo.get()));

  // No mimeinfo -> we can't continue. probably OOM.

  if (!mimeInfo) {

    return NS_ERROR_OUT_OF_MEMORY;

  }

  *aStreamListener = nullptr;

  // We want the mimeInfo's primary extension to pass it to

  // nsExternalAppHandler

  nsAutoCString buf;

  mimeInfo->GetPrimaryExtension(buf);

  // NB: ExternalHelperAppParent depends on this listener always being an

  // nsExternalAppHandler. If this changes, make sure to update that code.

  nsExternalAppHandler * handler = new nsExternalAppHandler(mimeInfo,

                                                            buf,

                                                            aContentContext,

                                                            aWindowContext,

                                                            this,

                                                            fileName,

                                                            reason,

                                                            aForceSave);

  if (!handler) {

    return NS_ERROR_OUT_OF_MEMORY;

  }

  NS_ADDREF(*aStreamListener = handler);

  return NS_OK;

}

NS_IMETHODIMP nsExternalHelperAppService::ApplyDecodingForExtension(const nsACString& aExtension,

                                                                    const nsACString& aEncodingType,

                                                                    bool *aApplyDecoding)

{

  *aApplyDecoding = true;

  uint32_t i;

  for(i = 0; i < ArrayLength(nonDecodableExtensions); ++i) {

    if (aExtension.LowerCaseEqualsASCII(nonDecodableExtensions[i].mFileExtension) &&

        aEncodingType.LowerCaseEqualsASCII(nonDecodableExtensions[i].mMimeType)) {

      *aApplyDecoding = false;

      break;

    }

  }

  return NS_OK;

}

nsresult nsExternalHelperAppService::GetFileTokenForPath(const char16_t * aPlatformAppPath,

                                                         nsIFile ** aFile)

{

  nsDependentString platformAppPath(aPlatformAppPath);

  // First, check if we have an absolute path

  nsIFile* localFile = nullptr;

  nsresult rv = NS_NewLocalFile(platformAppPath, true, &localFile);

  if (NS_SUCCEEDED(rv)) {

    *aFile = localFile;

    bool exists;

    if (NS_FAILED((*aFile)->Exists(&exists)) || !exists) {

      NS_RELEASE(*aFile);

      return NS_ERROR_FILE_NOT_FOUND;

    }

    return NS_OK;

  }

  // Second, check if file exists in mozilla program directory

  rv = NS_GetSpecialDirectory(NS_XPCOM_CURRENT_PROCESS_DIR, aFile);

  if (NS_SUCCEEDED(rv)) {

    rv = (*aFile)->Append(platformAppPath);

    if (NS_SUCCEEDED(rv)) {

      bool exists = false;

      rv = (*aFile)->Exists(&exists);

      if (NS_SUCCEEDED(rv) && exists)

        return NS_OK;

    }

    NS_RELEASE(*aFile);

  }

  return NS_ERROR_NOT_AVAILABLE;

}

//////////////////////////////////////////////////////////////////////////////////////////////////////

// begin external protocol service default implementation...

//////////////////////////////////////////////////////////////////////////////////////////////////////

NS_IMETHODIMP nsExternalHelperAppService::ExternalProtocolHandlerExists(const char * aProtocolScheme,

                                                                        bool * aHandlerExists)

{

  nsCOMPtr<nsIHandlerInfo> handlerInfo;

  nsresult rv = GetProtocolHandlerInfo(nsDependentCString(aProtocolScheme), 

                                       getter_AddRefs(handlerInfo));

  if (NS_SUCCEEDED(rv)) {

    // See if we have any known possible handler apps for this

    nsCOMPtr<nsIMutableArray> possibleHandlers;

    handlerInfo->GetPossibleApplicationHandlers(getter_AddRefs(possibleHandlers));

    uint32_t length;

    possibleHandlers->GetLength(&length);

    if (length) {

      *aHandlerExists = true;

      return NS_OK;

    }

  }

  // if not, fall back on an os-based handler

  return OSProtocolHandlerExists(aProtocolScheme, aHandlerExists);

}

NS_IMETHODIMP nsExternalHelperAppService::IsExposedProtocol(const char * aProtocolScheme, bool * aResult)

{

  // check the per protocol setting first.  it always takes precedence.

  // if not set, then use the global setting.

  nsAutoCString prefName("network.protocol-handler.expose.");

  prefName += aProtocolScheme;

  bool val;

  if (NS_SUCCEEDED(Preferences::GetBool(prefName.get(), &val))) {

    *aResult = val;

    return NS_OK;

  }

  // by default, no protocol is exposed.  i.e., by default all link clicks must

  // go through the external protocol service.  most applications override this

  // default behavior.

  *aResult =

    Preferences::GetBool("network.protocol-handler.expose-all", false);

  return NS_OK;

}

static const char kExternalProtocolPrefPrefix[]  = "network.protocol-handler.external.";

static const char kExternalProtocolDefaultPref[] = "network.protocol-handler.external-default";

NS_IMETHODIMP 

nsExternalHelperAppService::LoadURI(nsIURI *aURI,

                                    nsIInterfaceRequestor *aWindowContext)

{

  NS_ENSURE_ARG_POINTER(aURI);

  if (XRE_IsContentProcess()) {

    URIParams uri;

    SerializeURI(aURI, uri);

    nsCOMPtr<nsITabChild> tabChild(do_GetInterface(aWindowContext));

    mozilla::dom::ContentChild::GetSingleton()->