/* -*- Mode: C++; tab-width: 2; 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 "base/basictypes.h" /* This must occur *after* base/basictypes.h to avoid typedefs conflicts. */ #include "mozilla/ArrayUtils.h" #include "mozilla/Base64.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 "nsXPIDLString.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" // 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 "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 #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 "nsIDownloadHistory.h" // to mark downloads as visited #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 #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) { // First, we need a charset nsAutoCString originCharset; nsresult rv = aURI->GetOriginCharset(originCharset); NS_ENSURE_SUCCESS(rv, rv); // Now, we need the unescaper nsCOMPtr textToSubURI = do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); return textToSubURI->UnEscapeURIForUI(originCharset, 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 uri; aChannel->GetURI(getter_AddRefs(uri)); nsCOMPtr 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 nsDownloadManager.cpp * * Optionally skip availability of the directory and storage. */ static nsresult GetDownloadDirectory(nsIFile **_directory, bool aSkipChecks = false) { nsCOMPtr dir; // On all supported platforms, we default to the system's 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 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 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" }, { VIDEO_OGG, "ogv" }, { VIDEO_OGG, "ogg" }, { APPLICATION_OGG, "ogg" }, { AUDIO_OGG, "oga" }, { AUDIO_OGG, "opus" }, { APPLICATION_PDF, "pdf" }, { VIDEO_WEBM, "webm" }, { AUDIO_WEBM, "webm" }, { AUDIO_FLAC, "flac" }, #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; }; #define MAC_TYPE(x) 0 /** * 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[] = { { APPLICATION_OCTET_STREAM, "exe,com,bin", "Binary File" }, { 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" }, { 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" }, { 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 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 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 uri; int64_t contentLength = -1; bool wasFileChannel = false; uint32_t contentDisposition = -1; nsAutoString fileName; nsCOMPtr channel = do_QueryInterface(aRequest); if (channel) { channel->GetURI(getter_AddRefs(uri)); channel->GetContentLength(&contentLength); channel->GetContentDisposition(&contentDisposition); channel->GetContentDispositionFilename(fileName); channel->GetContentDispositionHeader(disp); nsCOMPtr fileChan(do_QueryInterface(aRequest)); wasFileChannel = fileChan != nullptr; } nsCOMPtr 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(pc); NS_ADDREF(*aStreamListener = childListener); uint32_t reason = nsIHelperAppLauncherDialog::REASON_CANTHANDLE; RefPtr 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 channel = do_QueryInterface(aRequest); nsCOMPtr 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 httpChan = do_QueryInterface(channel); if (httpChan) { nsAutoCString requestMethod; 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 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 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 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); 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 handlerInfo; nsresult rv = GetProtocolHandlerInfo(nsDependentCString(aProtocolScheme), getter_AddRefs(handlerInfo)); NS_ENSURE_SUCCESS(rv, rv); // See if we have any known possible handler apps for this nsCOMPtr 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; } NS_IMETHODIMP nsExternalHelperAppService::LoadUrl(nsIURI * aURL) { return LoadURI(aURL, nullptr); } static const char kExternalProtocolPrefPrefix[] = "network.protocol-handler.external."; static const char kExternalProtocolDefaultPref[] = "network.protocol-handler.external-default"; // static nsresult nsExternalHelperAppService::EscapeURI(nsIURI* aURI, nsIURI** aResult) { MOZ_ASSERT(aURI); MOZ_ASSERT(aResult); nsAutoCString spec; aURI->GetSpec(spec); if (spec.Find("%00") != -1) return NS_ERROR_MALFORMED_URI; nsAutoCString escapedSpec; nsresult rv = NS_EscapeURL(spec, esc_AlwaysCopy | esc_ExtHandler, escapedSpec, fallible); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr ios(do_GetIOService()); return ios->NewURI(escapedSpec, nullptr, nullptr, aResult); } NS_IMETHODIMP nsExternalHelperAppService::LoadURI(nsIURI *aURI, nsIInterfaceRequestor *aWindowContext) { NS_ENSURE_ARG_POINTER(aURI); if (XRE_IsContentProcess()) { URIParams uri; SerializeURI(aURI, uri); nsCOMPtr tabChild(do_GetInterface(aWindowContext)); mozilla::dom::ContentChild::GetSingleton()-> SendLoadURIExternal(uri, static_cast(tabChild.get())); return NS_OK; } nsCOMPtr escapedURI; nsresult rv = EscapeURI(aURI, getter_AddRefs(escapedURI)); NS_ENSURE_SUCCESS(rv, rv); nsAutoCString scheme; escapedURI->GetScheme(scheme); if (scheme.IsEmpty()) return NS_OK; // must have a scheme // Deny load if the prefs say to do so nsAutoCString externalPref(kExternalProtocolPrefPrefix); externalPref += scheme; bool allowLoad = false; if (NS_FAILED(Preferences::GetBool(externalPref.get(), &allowLoad))) { // no scheme-specific value, check the default if (NS_FAILED(Preferences::GetBool(kExternalProtocolDefaultPref, &allowLoad))) { return NS_OK; // missing default pref } } if (!allowLoad) { return NS_OK; // explicitly denied } nsCOMPtr handler; rv = GetProtocolHandlerInfo(scheme, getter_AddRefs(handler)); NS_ENSURE_SUCCESS(rv, rv); nsHandlerInfoAction preferredAction; handler->GetPreferredAction(&preferredAction); bool alwaysAsk = true; handler->GetAlwaysAskBeforeHandling(&alwaysAsk); // if we are not supposed to ask, and the preferred action is to use // a helper app or the system default, we just launch the URI. if (!alwaysAsk && (preferredAction == nsIHandlerInfo::useHelperApp || preferredAction == nsIHandlerInfo::useSystemDefault)) return handler->LaunchWithURI(escapedURI, aWindowContext); nsCOMPtr chooser = do_CreateInstance("@mozilla.org/content-dispatch-chooser;1", &rv); NS_ENSURE_SUCCESS(rv, rv); return chooser->Ask(handler, aWindowContext, escapedURI, nsIContentDispatchChooser::REASON_CANNOT_HANDLE); } NS_IMETHODIMP nsExternalHelperAppService::GetApplicationDescription(const nsACString& aScheme, nsAString& _retval) { // this method should only be implemented by each OS specific implementation of this service. return NS_ERROR_NOT_IMPLEMENTED; } ////////////////////////////////////////////////////////////////////////////////////////////////////// // Methods related to deleting temporary files on exit ////////////////////////////////////////////////////////////////////////////////////////////////////// /* static */ nsresult nsExternalHelperAppService::DeleteTemporaryFileHelper(nsIFile * aTemporaryFile, nsCOMArray &aFileList) { bool isFile = false; // as a safety measure, make sure the nsIFile is really a file and not a directory object. aTemporaryFile->IsFile(&isFile); if (!isFile) return NS_OK; aFileList.AppendObject(aTemporaryFile); return NS_OK; } NS_IMETHODIMP nsExternalHelperAppService::DeleteTemporaryFileOnExit(nsIFile* aTemporaryFile) { return DeleteTemporaryFileHelper(aTemporaryFile, mTemporaryFilesList); } NS_IMETHODIMP nsExternalHelperAppService::DeleteTemporaryPrivateFileWhenPossible(nsIFile* aTemporaryFile) { return DeleteTemporaryFileHelper(aTemporaryFile, mTemporaryPrivateFilesList); } void nsExternalHelperAppService::ExpungeTemporaryFilesHelper(nsCOMArray &fileList) { int32_t numEntries = fileList.Count(); nsIFile* localFile; for (int32_t index = 0; index < numEntries; index++) { localFile = fileList[index]; if (localFile) { // First make the file writable, since the temp file is probably readonly. localFile->SetPermissions(0600); localFile->Remove(false); } } fileList.Clear(); } void nsExternalHelperAppService::ExpungeTemporaryFiles() { ExpungeTemporaryFilesHelper(mTemporaryFilesList); } void nsExternalHelperAppService::ExpungeTemporaryPrivateFiles() { ExpungeTemporaryFilesHelper(mTemporaryPrivateFilesList); } static const char kExternalWarningPrefPrefix[] = "network.protocol-handler.warn-external."; static const char kExternalWarningDefaultPref[] = "network.protocol-handler.warn-external-default"; NS_IMETHODIMP nsExternalHelperAppService::GetProtocolHandlerInfo(const nsACString &aScheme, nsIHandlerInfo **aHandlerInfo) { // XXX enterprise customers should be able to turn this support off with a // single master pref (maybe use one of the "exposed" prefs here?) bool exists; nsresult rv = GetProtocolHandlerInfoFromOS(aScheme, &exists, aHandlerInfo); if (NS_FAILED(rv)) { // Either it knows nothing, or we ran out of memory return NS_ERROR_FAILURE; } nsCOMPtr handlerSvc = do_GetService(NS_HANDLERSERVICE_CONTRACTID); if (handlerSvc) { bool hasHandler = false; (void) handlerSvc->Exists(*aHandlerInfo, &hasHandler); if (hasHandler) { rv = handlerSvc->FillHandlerInfo(*aHandlerInfo, EmptyCString()); if (NS_SUCCEEDED(rv)) return NS_OK; } } return SetProtocolHandlerDefaults(*aHandlerInfo, exists); } NS_IMETHODIMP nsExternalHelperAppService::GetProtocolHandlerInfoFromOS(const nsACString &aScheme, bool *found, nsIHandlerInfo **aHandlerInfo) { // intended to be implemented by the subclass return NS_ERROR_NOT_IMPLEMENTED; } NS_IMETHODIMP nsExternalHelperAppService::SetProtocolHandlerDefaults(nsIHandlerInfo *aHandlerInfo, bool aOSHandlerExists) { // this type isn't in our database, so we've only got an OS default handler, // if one exists if (aOSHandlerExists) { // we've got a default, so use it aHandlerInfo->SetPreferredAction(nsIHandlerInfo::useSystemDefault); // whether or not to ask the user depends on the warning preference nsAutoCString scheme; aHandlerInfo->GetType(scheme); nsAutoCString warningPref(kExternalWarningPrefPrefix); warningPref += scheme; bool warn; if (NS_FAILED(Preferences::GetBool(warningPref.get(), &warn))) { // no scheme-specific value, check the default warn = Preferences::GetBool(kExternalWarningDefaultPref, true); } aHandlerInfo->SetAlwaysAskBeforeHandling(warn); } else { // If no OS default existed, we set the preferred action to alwaysAsk. // This really means not initialized (i.e. there's no available handler) // to all the code... aHandlerInfo->SetPreferredAction(nsIHandlerInfo::alwaysAsk); } return NS_OK; } // XPCOM profile change observer NS_IMETHODIMP nsExternalHelperAppService::Observe(nsISupports *aSubject, const char *aTopic, const char16_t *someData ) { if (!strcmp(aTopic, "profile-before-change")) { ExpungeTemporaryFiles(); } else if (!strcmp(aTopic, "last-pb-context-exited")) { ExpungeTemporaryPrivateFiles(); } return NS_OK; } ////////////////////////////////////////////////////////////////////////////////////////////////////// // begin external app handler implementation ////////////////////////////////////////////////////////////////////////////////////////////////////// NS_IMPL_ADDREF(nsExternalAppHandler) NS_IMPL_RELEASE(nsExternalAppHandler) NS_INTERFACE_MAP_BEGIN(nsExternalAppHandler) NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIStreamListener) NS_INTERFACE_MAP_ENTRY(nsIStreamListener) NS_INTERFACE_MAP_ENTRY(nsIRequestObserver) NS_INTERFACE_MAP_ENTRY(nsIHelperAppLauncher) NS_INTERFACE_MAP_ENTRY(nsICancelable) NS_INTERFACE_MAP_ENTRY(nsITimerCallback) NS_INTERFACE_MAP_ENTRY(nsIBackgroundFileSaverObserver) NS_INTERFACE_MAP_END_THREADSAFE nsExternalAppHandler::nsExternalAppHandler(nsIMIMEInfo * aMIMEInfo, const nsCSubstring& aTempFileExtension, nsIInterfaceRequestor* aContentContext, nsIInterfaceRequestor* aWindowContext, nsExternalHelperAppService *aExtProtSvc, const nsAString& aSuggestedFilename, uint32_t aReason, bool aForceSave) : mMimeInfo(aMIMEInfo) , mContentContext(aContentContext) , mWindowContext(aWindowContext) , mWindowToClose(nullptr) , mSuggestedFileName(aSuggestedFilename) , mForceSave(aForceSave) , mCanceled(false) , mShouldCloseWindow(false) , mStopRequestIssued(false) , mReason(aReason) , mContentLength(-1) , mProgress(0) , mSaver(nullptr) , mDialogProgressListener(nullptr) , mTransfer(nullptr) , mRequest(nullptr) , mExtProtSvc(aExtProtSvc) { // make sure the extention includes the '.' if (!aTempFileExtension.IsEmpty() && aTempFileExtension.First() != '.') mTempFileExtension = char16_t('.'); AppendUTF8toUTF16(aTempFileExtension, mTempFileExtension); // Replace platform specific path separator and illegal characters to avoid any confusion mSuggestedFileName.ReplaceChar(KNOWN_PATH_SEPARATORS, '_'); mSuggestedFileName.ReplaceChar(FILE_ILLEGAL_CHARACTERS, ' '); mSuggestedFileName.ReplaceChar(char16_t(0), '_'); mTempFileExtension.ReplaceChar(KNOWN_PATH_SEPARATORS, '_'); mTempFileExtension.ReplaceChar(FILE_ILLEGAL_CHARACTERS, ' '); // Remove unsafe bidi characters which might have spoofing implications (bug 511521). const char16_t unsafeBidiCharacters[] = { char16_t(0x061c), // Arabic Letter Mark char16_t(0x200e), // Left-to-Right Mark char16_t(0x200f), // Right-to-Left Mark char16_t(0x202a), // Left-to-Right Embedding char16_t(0x202b), // Right-to-Left Embedding char16_t(0x202c), // Pop Directional Formatting char16_t(0x202d), // Left-to-Right Override char16_t(0x202e), // Right-to-Left Override char16_t(0x2066), // Left-to-Right Isolate char16_t(0x2067), // Right-to-Left Isolate char16_t(0x2068), // First Strong Isolate char16_t(0x2069), // Pop Directional Isolate char16_t(0) }; mSuggestedFileName.ReplaceChar(unsafeBidiCharacters, '_'); mTempFileExtension.ReplaceChar(unsafeBidiCharacters, '_'); // Make sure extension is correct. EnsureSuggestedFileName(); mBufferSize = Preferences::GetUint("network.buffer.cache.size", 4096); } nsExternalAppHandler::~nsExternalAppHandler() { MOZ_ASSERT(!mSaver, "Saver should hold a reference to us until deleted"); } void nsExternalAppHandler::DidDivertRequest(nsIRequest *request) { MOZ_ASSERT(XRE_IsContentProcess(), "in child process"); // Remove our request from the child loadGroup RetargetLoadNotifications(request); MaybeCloseWindow(); } NS_IMETHODIMP nsExternalAppHandler::SetWebProgressListener(nsIWebProgressListener2 * aWebProgressListener) { // This is always called by nsHelperDlg.js. Go ahead and register the // progress listener. At this point, we don't have mTransfer. mDialogProgressListener = aWebProgressListener; return NS_OK; } NS_IMETHODIMP nsExternalAppHandler::GetTargetFile(nsIFile** aTarget) { if (mFinalFileDestination) *aTarget = mFinalFileDestination; else *aTarget = mTempFile; NS_IF_ADDREF(*aTarget); return NS_OK; } NS_IMETHODIMP nsExternalAppHandler::GetTargetFileIsExecutable(bool *aExec) { // Use the real target if it's been set if (mFinalFileDestination) return mFinalFileDestination->IsExecutable(aExec); // Otherwise, use the stored executable-ness of the temporary *aExec = mTempFileIsExecutable; return NS_OK; } NS_IMETHODIMP nsExternalAppHandler::GetTimeDownloadStarted(PRTime* aTime) { *aTime = mTimeDownloadStarted; return NS_OK; } NS_IMETHODIMP nsExternalAppHandler::GetContentLength(int64_t *aContentLength) { *aContentLength = mContentLength; return NS_OK; } void nsExternalAppHandler::RetargetLoadNotifications(nsIRequest *request) { // we are going to run the downloading of the helper app in our own little docloader / load group context. // so go ahead and force the creation of a load group and doc loader for us to use... nsCOMPtr aChannel = do_QueryInterface(request); if (!aChannel) return; // we need to store off the original (pre redirect!) channel that initiated the load. We do // this so later on, we can pass any refresh urls associated with the original channel back to the // window context which started the whole process. More comments about that are listed below.... // HACK ALERT: it's pretty bogus that we are getting the document channel from the doc loader. // ideally we should be able to just use mChannel (the channel we are extracting content from) or // the default load channel associated with the original load group. Unfortunately because // a redirect may have occurred, the doc loader is the only one with a ptr to the original channel // which is what we really want.... // Note that we need to do this before removing aChannel from the loadgroup, // since that would mess with the original channel on the loader. nsCOMPtr origContextLoader = do_GetInterface(mContentContext); if (origContextLoader) { origContextLoader->GetDocumentChannel(getter_AddRefs(mOriginalChannel)); } bool isPrivate = NS_UsePrivateBrowsing(aChannel); nsCOMPtr oldLoadGroup; aChannel->GetLoadGroup(getter_AddRefs(oldLoadGroup)); if(oldLoadGroup) { oldLoadGroup->RemoveRequest(request, nullptr, NS_BINDING_RETARGETED); } aChannel->SetLoadGroup(nullptr); aChannel->SetNotificationCallbacks(nullptr); nsCOMPtr pbChannel = do_QueryInterface(aChannel); if (pbChannel) { pbChannel->SetPrivate(isPrivate); } } /** * Make mTempFileExtension contain an extension exactly when its previous value * is different from mSuggestedFileName's extension, so that it can be appended * to mSuggestedFileName and form a valid, useful leaf name. * This is required so that the (renamed) temporary file has the correct extension * after downloading to make sure the OS will launch the application corresponding * to the MIME type (which was used to calculate mTempFileExtension). This prevents * a cgi-script named foobar.exe that returns application/zip from being named * foobar.exe and executed as an executable file. It also blocks content that * a web site might provide with a content-disposition header indicating * filename="foobar.exe" from being downloaded to a file with extension .exe * and executed. */ void nsExternalAppHandler::EnsureSuggestedFileName() { // Make sure there is a mTempFileExtension (not "" or "."). // Remember that mTempFileExtension will always have the leading "." // (the check for empty is just to be safe). if (mTempFileExtension.Length() > 1) { // Get mSuggestedFileName's current extension. nsAutoString fileExt; int32_t pos = mSuggestedFileName.RFindChar('.'); if (pos != kNotFound) mSuggestedFileName.Right(fileExt, mSuggestedFileName.Length() - pos); // Now, compare fileExt to mTempFileExtension. if (fileExt.Equals(mTempFileExtension, nsCaseInsensitiveStringComparator())) { // Matches -> mTempFileExtension can be empty mTempFileExtension.Truncate(); } } } nsresult nsExternalAppHandler::SetUpTempFile(nsIChannel * aChannel) { // First we need to try to get the destination directory for the temporary // file. nsresult rv = GetDownloadDirectory(getter_AddRefs(mTempFile)); NS_ENSURE_SUCCESS(rv, rv); // At this point, we do not have a filename for the temp file. For security // purposes, this cannot be predictable, so we must use a cryptographic // quality PRNG to generate one. // We will request raw random bytes, and transform that to a base64 string, // as all characters from the base64 set are acceptable for filenames. For // each three bytes of random data, we will get four bytes of ASCII. Request // a bit more, to be safe, and truncate to the length we want in the end. const uint32_t wantedFileNameLength = 8; const uint32_t requiredBytesLength = static_cast((wantedFileNameLength + 1) / 4 * 3); nsCOMPtr rg = do_GetService("@mozilla.org/security/random-generator;1", &rv); NS_ENSURE_SUCCESS(rv, rv); uint8_t *buffer; rv = rg->GenerateRandomBytes(requiredBytesLength, &buffer); NS_ENSURE_SUCCESS(rv, rv); nsAutoCString tempLeafName; nsDependentCSubstring randomData(reinterpret_cast(buffer), requiredBytesLength); rv = Base64Encode(randomData, tempLeafName); free(buffer); buffer = nullptr; NS_ENSURE_SUCCESS(rv, rv); tempLeafName.Truncate(wantedFileNameLength); // Base64 characters are alphanumeric (a-zA-Z0-9) and '+' and '/', so we need // to replace illegal characters -- notably '/' tempLeafName.ReplaceChar(KNOWN_PATH_SEPARATORS FILE_ILLEGAL_CHARACTERS, '_'); // now append our extension. nsAutoCString ext; mMimeInfo->GetPrimaryExtension(ext); if (!ext.IsEmpty()) { ext.ReplaceChar(KNOWN_PATH_SEPARATORS FILE_ILLEGAL_CHARACTERS, '_'); if (ext.First() != '.') tempLeafName.Append('.'); tempLeafName.Append(ext); } // We need to temporarily create a dummy file with the correct // file extension to determine the executable-ness, so do this before adding // the extra .part extension. nsCOMPtr dummyFile; rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(dummyFile)); NS_ENSURE_SUCCESS(rv, rv); // Set the file name without .part rv = dummyFile->Append(NS_ConvertUTF8toUTF16(tempLeafName)); NS_ENSURE_SUCCESS(rv, rv); rv = dummyFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600); NS_ENSURE_SUCCESS(rv, rv); // Store executable-ness then delete dummyFile->IsExecutable(&mTempFileIsExecutable); dummyFile->Remove(false); // Add an additional .part to prevent the OS from running this file in the // default application. tempLeafName.AppendLiteral(".part"); rv = mTempFile->Append(NS_ConvertUTF8toUTF16(tempLeafName)); // make this file unique!!! NS_ENSURE_SUCCESS(rv, rv); rv = mTempFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600); NS_ENSURE_SUCCESS(rv, rv); // Now save the temp leaf name, minus the ".part" bit, so we can use it later. // This is a bit broken in the case when createUnique actually had to append // some numbers, because then we now have a filename like foo.bar-1.part and // we'll end up with foo.bar-1.bar as our final filename if we end up using // this. But the other options are all bad too.... Ideally we'd have a way // to tell createUnique to put its unique marker before the extension that // comes before ".part" or something. rv = mTempFile->GetLeafName(mTempLeafName); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_TRUE(StringEndsWith(mTempLeafName, NS_LITERAL_STRING(".part")), NS_ERROR_UNEXPECTED); // Strip off the ".part" from mTempLeafName mTempLeafName.Truncate(mTempLeafName.Length() - ArrayLength(".part") + 1); MOZ_ASSERT(!mSaver, "Output file initialization called more than once!"); mSaver = do_CreateInstance(NS_BACKGROUNDFILESAVERSTREAMLISTENER_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); rv = mSaver->SetObserver(this); if (NS_FAILED(rv)) { mSaver = nullptr; return rv; } rv = mSaver->EnableSha256(); NS_ENSURE_SUCCESS(rv, rv); rv = mSaver->EnableSignatureInfo(); NS_ENSURE_SUCCESS(rv, rv); LOG(("Enabled hashing and signature verification")); rv = mSaver->SetTarget(mTempFile, false); NS_ENSURE_SUCCESS(rv, rv); return rv; } void nsExternalAppHandler::MaybeApplyDecodingForExtension(nsIRequest *aRequest) { MOZ_ASSERT(aRequest); nsCOMPtr encChannel = do_QueryInterface(aRequest); if (!encChannel) { return; } // Turn off content encoding conversions if needed bool applyConversion = true; // First, check to see if conversion is already disabled. If so, we // have nothing to do here. encChannel->GetApplyConversion(&applyConversion); if (!applyConversion) { return; } nsCOMPtr sourceURL(do_QueryInterface(mSourceUrl)); if (sourceURL) { nsAutoCString extension; sourceURL->GetFileExtension(extension); if (!extension.IsEmpty()) { nsCOMPtr encEnum; encChannel->GetContentEncodings(getter_AddRefs(encEnum)); if (encEnum) { bool hasMore; nsresult rv = encEnum->HasMore(&hasMore); if (NS_SUCCEEDED(rv) && hasMore) { nsAutoCString encType; rv = encEnum->GetNext(encType); if (NS_SUCCEEDED(rv) && !encType.IsEmpty()) { MOZ_ASSERT(mExtProtSvc); mExtProtSvc->ApplyDecodingForExtension(extension, encType, &applyConversion); } } } } } encChannel->SetApplyConversion( applyConversion ); return; } NS_IMETHODIMP nsExternalAppHandler::OnStartRequest(nsIRequest *request, nsISupports * aCtxt) { NS_PRECONDITION(request, "OnStartRequest without request?"); // Set mTimeDownloadStarted here as the download has already started and // we want to record the start time before showing the filepicker. mTimeDownloadStarted = PR_Now(); mRequest = request; nsCOMPtr aChannel = do_QueryInterface(request); nsresult rv; nsCOMPtr fileChan(do_QueryInterface(request)); mIsFileChannel = fileChan != nullptr; if (!mIsFileChannel) { // It's possible that this request came from the child process and the // file channel actually lives there. If this returns true, then our // mSourceUrl will be an nsIFileURL anyway. nsCOMPtr parent(do_QueryInterface(request)); mIsFileChannel = parent && parent->WasFileChannel(); } // Get content length if (aChannel) { aChannel->GetContentLength(&mContentLength); } nsCOMPtr props(do_QueryInterface(request, &rv)); // Determine whether a new window was opened specifically for this request if (props) { bool tmp = false; props->GetPropertyAsBool(NS_LITERAL_STRING("docshell.newWindowTarget"), &tmp); mShouldCloseWindow = tmp; } // Now get the URI if (aChannel) { aChannel->GetURI(getter_AddRefs(mSourceUrl)); } // retarget all load notifications to our docloader instead of the original window's docloader... RetargetLoadNotifications(request); // Check to see if there is a refresh header on the original channel. if (mOriginalChannel) { nsCOMPtr httpChannel(do_QueryInterface(mOriginalChannel)); if (httpChannel) { nsAutoCString refreshHeader; httpChannel->GetResponseHeader(NS_LITERAL_CSTRING("refresh"), refreshHeader); if (!refreshHeader.IsEmpty()) { mShouldCloseWindow = false; } } } // Close the underlying DOMWindow if there is no refresh header // and it was opened specifically for the download MaybeCloseWindow(); // In an IPC setting, we're allowing the child process, here, to make // decisions about decoding the channel (e.g. decompression). It will // still forward the decoded (uncompressed) data back to the parent. // Con: Uncompressed data means more IPC overhead. // Pros: ExternalHelperAppParent doesn't need to implement nsIEncodedChannel. // Parent process doesn't need to expect CPU time on decompression. MaybeApplyDecodingForExtension(aChannel); // At this point, the child process has done everything it can usefully do // for OnStartRequest. if (XRE_IsContentProcess()) { return NS_OK; } rv = SetUpTempFile(aChannel); if (NS_FAILED(rv)) { nsresult transferError = rv; rv = CreateFailedTransfer(aChannel && NS_UsePrivateBrowsing(aChannel)); if (NS_FAILED(rv)) { LOG(("Failed to create transfer to report failure." "Will fallback to prompter!")); } mCanceled = true; request->Cancel(transferError); nsAutoString path; if (mTempFile) mTempFile->GetPath(path); SendStatusChange(kWriteError, transferError, request, path); return NS_OK; } // Inform channel it is open on behalf of a download to prevent caching. nsCOMPtr httpInternal = do_QueryInterface(aChannel); if (httpInternal) { httpInternal->SetChannelIsForDownload(true); } // now that the temp file is set up, find out if we need to invoke a dialog // asking the user what they want us to do with this content... // We can get here for three reasons: "can't handle", "sniffed type", or // "server sent content-disposition:attachment". In the first case we want // to honor the user's "always ask" pref; in the other two cases we want to // honor it only if the default action is "save". Opening attachments in // helper apps by default breaks some websites (especially if the attachment // is one part of a multipart document). Opening sniffed content in helper // apps by default introduces security holes that we'd rather not have. // So let's find out whether the user wants to be prompted. If he does not, // check mReason and the preferred action to see what we should do. bool alwaysAsk = true; mMimeInfo->GetAlwaysAskBeforeHandling(&alwaysAsk); if (alwaysAsk) { // But we *don't* ask if this mimeInfo didn't come from // our user configuration datastore and the user has said // at some point in the distant past that they don't // want to be asked. The latter fact would have been // stored in pref strings back in the old days. bool mimeTypeIsInDatastore = false; nsCOMPtr handlerSvc = do_GetService(NS_HANDLERSERVICE_CONTRACTID); if (handlerSvc) { handlerSvc->Exists(mMimeInfo, &mimeTypeIsInDatastore); } if (!handlerSvc || !mimeTypeIsInDatastore) { nsAutoCString MIMEType; mMimeInfo->GetMIMEType(MIMEType); if (!GetNeverAskFlagFromPref(NEVER_ASK_FOR_SAVE_TO_DISK_PREF, MIMEType.get())) { // Don't need to ask after all. alwaysAsk = false; // Make sure action matches pref (save to disk). mMimeInfo->SetPreferredAction(nsIMIMEInfo::saveToDisk); } else if (!GetNeverAskFlagFromPref(NEVER_ASK_FOR_OPEN_FILE_PREF, MIMEType.get())) { // Don't need to ask after all. alwaysAsk = false; } } } int32_t action = nsIMIMEInfo::saveToDisk; mMimeInfo->GetPreferredAction( &action ); // OK, now check why we're here if (!alwaysAsk && mReason != nsIHelperAppLauncherDialog::REASON_CANTHANDLE) { // Force asking if we're not saving. See comment back when we fetched the // alwaysAsk boolean for details. alwaysAsk = (action != nsIMIMEInfo::saveToDisk); } // if we were told that we _must_ save to disk without asking, all the stuff // before this is irrelevant; override it if (mForceSave) { alwaysAsk = false; action = nsIMIMEInfo::saveToDisk; } if (alwaysAsk) { // Display the dialog mDialog = do_CreateInstance(NS_HELPERAPPLAUNCHERDLG_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); // this will create a reference cycle (the dialog holds a reference to us as // nsIHelperAppLauncher), which will be broken in Cancel or CreateTransfer. rv = mDialog->Show(this, GetDialogParent(), mReason); // what do we do if the dialog failed? I guess we should call Cancel and abort the load.... } else { // We need to do the save/open immediately, then. #ifdef XP_WIN /* We need to see whether the file we've got here could be * executable. If it could, we had better not try to open it! * We can skip this check, though, if we have a setting to open in a * helper app. * This code mirrors the code in * nsExternalAppHandler::LaunchWithApplication so that what we * test here is as close as possible to what will really be * happening if we decide to execute */ nsCOMPtr prefApp; mMimeInfo->GetPreferredApplicationHandler(getter_AddRefs(prefApp)); if (action != nsIMIMEInfo::useHelperApp || !prefApp) { nsCOMPtr fileToTest; GetTargetFile(getter_AddRefs(fileToTest)); if (fileToTest) { bool isExecutable; rv = fileToTest->IsExecutable(&isExecutable); if (NS_FAILED(rv) || isExecutable) { // checking NS_FAILED, because paranoia is good action = nsIMIMEInfo::saveToDisk; } } else { // Paranoia is good here too, though this really should not happen NS_WARNING("GetDownloadInfo returned a null file after the temp file has been set up! "); action = nsIMIMEInfo::saveToDisk; } } #endif if (action == nsIMIMEInfo::useHelperApp || action == nsIMIMEInfo::useSystemDefault) { rv = LaunchWithApplication(nullptr, false); } else { rv = SaveToDisk(nullptr, false); } } return NS_OK; } // Convert error info into proper message text and send OnStatusChange // notification to the dialog progress listener or nsITransfer implementation. void nsExternalAppHandler::SendStatusChange(ErrorType type, nsresult rv, nsIRequest *aRequest, const nsAFlatString &path) { nsAutoString msgId; switch (rv) { case NS_ERROR_OUT_OF_MEMORY: // No memory msgId.AssignLiteral("noMemory"); break; case NS_ERROR_FILE_DISK_FULL: case NS_ERROR_FILE_NO_DEVICE_SPACE: // Out of space on target volume. msgId.AssignLiteral("diskFull"); break; case NS_ERROR_FILE_READ_ONLY: // Attempt to write to read/only file. msgId.AssignLiteral("readOnly"); break; case NS_ERROR_FILE_ACCESS_DENIED: if (type == kWriteError) { // Attempt to write without sufficient permissions. msgId.AssignLiteral("accessError"); } else { msgId.AssignLiteral("launchError"); } break; case NS_ERROR_FILE_NOT_FOUND: case NS_ERROR_FILE_TARGET_DOES_NOT_EXIST: case NS_ERROR_FILE_UNRECOGNIZED_PATH: // Helper app not found, let's verify this happened on launch if (type == kLaunchError) { msgId.AssignLiteral("helperAppNotFound"); break; } MOZ_FALLTHROUGH; default: // Generic read/write/launch error message. switch (type) { case kReadError: msgId.AssignLiteral("readError"); break; case kWriteError: msgId.AssignLiteral("writeError"); break; case kLaunchError: msgId.AssignLiteral("launchError"); break; } break; } MOZ_LOG(nsExternalHelperAppService::mLog, LogLevel::Error, ("Error: %s, type=%i, listener=0x%p, transfer=0x%p, rv=0x%08X\n", NS_LossyConvertUTF16toASCII(msgId).get(), type, mDialogProgressListener.get(), mTransfer.get(), rv)); MOZ_LOG(nsExternalHelperAppService::mLog, LogLevel::Error, (" path='%s'\n", NS_ConvertUTF16toUTF8(path).get())); // Get properties file bundle and extract status string. nsCOMPtr stringService = mozilla::services::GetStringBundleService(); if (stringService) { nsCOMPtr bundle; if (NS_SUCCEEDED(stringService->CreateBundle("chrome://global/locale/nsWebBrowserPersist.properties", getter_AddRefs(bundle)))) { nsXPIDLString msgText; const char16_t *strings[] = { path.get() }; if (NS_SUCCEEDED(bundle->FormatStringFromName(msgId.get(), strings, 1, getter_Copies(msgText)))) { if (mDialogProgressListener) { // We have a listener, let it handle the error. mDialogProgressListener->OnStatusChange(nullptr, (type == kReadError) ? aRequest : nullptr, rv, msgText); } else if (mTransfer) { mTransfer->OnStatusChange(nullptr, (type == kReadError) ? aRequest : nullptr, rv, msgText); } else if (XRE_IsParentProcess()) { // We don't have a listener. Simply show the alert ourselves. nsresult qiRv; nsCOMPtr prompter(do_GetInterface(GetDialogParent(), &qiRv)); nsXPIDLString title; bundle->FormatStringFromName(u"title", strings, 1, getter_Copies(title)); MOZ_LOG(nsExternalHelperAppService::mLog, LogLevel::Debug, ("mContentContext=0x%p, prompter=0x%p, qi rv=0x%08X, title='%s', msg='%s'", mContentContext.get(), prompter.get(), qiRv, NS_ConvertUTF16toUTF8(title).get(), NS_ConvertUTF16toUTF8(msgText).get())); // If we didn't have a prompter we will try and get a window // instead, get it's docshell and use it to alert the user. if (!prompter) { nsCOMPtr window(do_GetInterface(GetDialogParent())); if (!window || !window->GetDocShell()) { return; } prompter = do_GetInterface(window->GetDocShell(), &qiRv); MOZ_LOG(nsExternalHelperAppService::mLog, LogLevel::Debug, ("No prompter from mContentContext, using DocShell, " \ "window=0x%p, docShell=0x%p, " \ "prompter=0x%p, qi rv=0x%08X", window.get(), window->GetDocShell(), prompter.get(), qiRv)); // If we still don't have a prompter, there's nothing else we // can do so just return. if (!prompter) { MOZ_LOG(nsExternalHelperAppService::mLog, LogLevel::Error, ("No prompter from DocShell, no way to alert user")); return; } } // We should always have a prompter at this point. prompter->Alert(title, msgText); } } } } } NS_IMETHODIMP nsExternalAppHandler::OnDataAvailable(nsIRequest *request, nsISupports * aCtxt, nsIInputStream * inStr, uint64_t sourceOffset, uint32_t count) { nsresult rv = NS_OK; // first, check to see if we've been canceled.... if (mCanceled || !mSaver) { // then go cancel our underlying channel too return request->Cancel(NS_BINDING_ABORTED); } // read the data out of the stream and write it to the temp file. if (count > 0) { mProgress += count; nsCOMPtr saver = do_QueryInterface(mSaver); rv = saver->OnDataAvailable(request, aCtxt, inStr, sourceOffset, count); if (NS_SUCCEEDED(rv)) { // Send progress notification. if (mTransfer) { mTransfer->OnProgressChange64(nullptr, request, mProgress, mContentLength, mProgress, mContentLength); } } else { // An error occurred, notify listener. nsAutoString tempFilePath; if (mTempFile) { mTempFile->GetPath(tempFilePath); } SendStatusChange(kReadError, rv, request, tempFilePath); // Cancel the download. Cancel(rv); } } return rv; } NS_IMETHODIMP nsExternalAppHandler::OnStopRequest(nsIRequest *request, nsISupports *aCtxt, nsresult aStatus) { LOG(("nsExternalAppHandler::OnStopRequest\n" " mCanceled=%d, mTransfer=0x%p, aStatus=0x%08X\n", mCanceled, mTransfer.get(), aStatus)); mStopRequestIssued = true; // Cancel if the request did not complete successfully. if (!mCanceled && NS_FAILED(aStatus)) { // Send error notification. nsAutoString tempFilePath; if (mTempFile) mTempFile->GetPath(tempFilePath); SendStatusChange( kReadError, aStatus, request, tempFilePath ); Cancel(aStatus); } // first, check to see if we've been canceled.... if (mCanceled || !mSaver) { return NS_OK; } return mSaver->Finish(NS_OK); } NS_IMETHODIMP nsExternalAppHandler::OnTargetChange(nsIBackgroundFileSaver *aSaver, nsIFile *aTarget) { return NS_OK; } NS_IMETHODIMP nsExternalAppHandler::OnSaveComplete(nsIBackgroundFileSaver *aSaver, nsresult aStatus) { LOG(("nsExternalAppHandler::OnSaveComplete\n" " aSaver=0x%p, aStatus=0x%08X, mCanceled=%d, mTransfer=0x%p\n", aSaver, aStatus, mCanceled, mTransfer.get())); if (!mCanceled) { // Save the hash and signature information (void)mSaver->GetSha256Hash(mHash); (void)mSaver->GetSignatureInfo(getter_AddRefs(mSignatureInfo)); // Free the reference that the saver keeps on us, even if we couldn't get // the hash. mSaver = nullptr; // Save the redirect information. nsCOMPtr channel = do_QueryInterface(mRequest); if (channel) { nsCOMPtr loadInfo = channel->GetLoadInfo(); if (loadInfo) { nsresult rv = NS_OK; nsCOMPtr redirectChain = do_CreateInstance(NS_ARRAY_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); LOG(("nsExternalAppHandler: Got %u redirects\n", loadInfo->RedirectChain().Length())); for (nsIPrincipal* principal : loadInfo->RedirectChain()) { redirectChain->AppendElement(principal, false); } mRedirects = redirectChain; } } if (NS_FAILED(aStatus)) { nsAutoString path; mTempFile->GetPath(path); // It may happen when e10s is enabled that there will be no transfer // object available to communicate status as expected by the system. // Let's try and create a temporary transfer object to take care of this // for us, we'll fall back to using the prompt service if we absolutely // have to. if (!mTransfer) { // We don't care if this fails. CreateFailedTransfer(channel && NS_UsePrivateBrowsing(channel)); } SendStatusChange(kWriteError, aStatus, nullptr, path); if (!mCanceled) Cancel(aStatus); return NS_OK; } } // Notify the transfer object that we are done if the user has chosen an // action. If the user hasn't chosen an action, the progress listener // (nsITransfer) will be notified in CreateTransfer. if (mTransfer) { NotifyTransfer(aStatus); } return NS_OK; } void nsExternalAppHandler::NotifyTransfer(nsresult aStatus) { MOZ_ASSERT(NS_IsMainThread(), "Must notify on main thread"); MOZ_ASSERT(mTransfer, "We must have an nsITransfer"); LOG(("Notifying progress listener")); if (NS_SUCCEEDED(aStatus)) { (void)mTransfer->SetSha256Hash(mHash); (void)mTransfer->SetSignatureInfo(mSignatureInfo); (void)mTransfer->SetRedirects(mRedirects); (void)mTransfer->OnProgressChange64(nullptr, nullptr, mProgress, mContentLength, mProgress, mContentLength); } (void)mTransfer->OnStateChange(nullptr, nullptr, nsIWebProgressListener::STATE_STOP | nsIWebProgressListener::STATE_IS_REQUEST | nsIWebProgressListener::STATE_IS_NETWORK, aStatus); // This nsITransfer object holds a reference to us (we are its observer), so // we need to release the reference to break a reference cycle (and therefore // to prevent leaking). We do this even if the previous calls failed. mTransfer = nullptr; } NS_IMETHODIMP nsExternalAppHandler::GetMIMEInfo(nsIMIMEInfo ** aMIMEInfo) { *aMIMEInfo = mMimeInfo; NS_ADDREF(*aMIMEInfo); return NS_OK; } NS_IMETHODIMP nsExternalAppHandler::GetSource(nsIURI ** aSourceURI) { NS_ENSURE_ARG(aSourceURI); *aSourceURI = mSourceUrl; NS_IF_ADDREF(*aSourceURI); return NS_OK; } NS_IMETHODIMP nsExternalAppHandler::GetSuggestedFileName(nsAString& aSuggestedFileName) { aSuggestedFileName = mSuggestedFileName; return NS_OK; } nsresult nsExternalAppHandler::CreateTransfer() { LOG(("nsExternalAppHandler::CreateTransfer")); MOZ_ASSERT(NS_IsMainThread(), "Must create transfer on main thread"); // We are back from the helper app dialog (where the user chooses to save or // open), but we aren't done processing the load. in this case, throw up a // progress dialog so the user can see what's going on. // Also, release our reference to mDialog. We don't need it anymore, and we // need to break the reference cycle. mDialog = nullptr; if (!mDialogProgressListener) { NS_WARNING("The dialog should nullify the dialog progress listener"); } nsresult rv; // We must be able to create an nsITransfer object. If not, it doesn't matter // much that we can't launch the helper application or save to disk. Work on // a local copy rather than mTransfer until we know we succeeded, to make it // clearer that this function is re-entrant. nsCOMPtr transfer = do_CreateInstance( NS_TRANSFER_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); // Initialize the download nsCOMPtr target; rv = NS_NewFileURI(getter_AddRefs(target), mFinalFileDestination); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr channel = do_QueryInterface(mRequest); rv = transfer->Init(mSourceUrl, target, EmptyString(), mMimeInfo, mTimeDownloadStarted, mTempFile, this, channel && NS_UsePrivateBrowsing(channel)); NS_ENSURE_SUCCESS(rv, rv); // Now let's add the download to history nsCOMPtr dh(do_GetService(NS_DOWNLOADHISTORY_CONTRACTID)); if (dh) { if (channel && !NS_UsePrivateBrowsing(channel)) { nsCOMPtr referrer; NS_GetReferrerFromChannel(channel, getter_AddRefs(referrer)); dh->AddDownload(mSourceUrl, referrer, mTimeDownloadStarted, target); } } // If we were cancelled since creating the transfer, just return. It is // always ok to return NS_OK if we are cancelled. Callers of this function // must call Cancel if CreateTransfer fails, but there's no need to cancel // twice. if (mCanceled) { return NS_OK; } rv = transfer->OnStateChange(nullptr, mRequest, nsIWebProgressListener::STATE_START | nsIWebProgressListener::STATE_IS_REQUEST | nsIWebProgressListener::STATE_IS_NETWORK, NS_OK); NS_ENSURE_SUCCESS(rv, rv); if (mCanceled) { return NS_OK; } mRequest = nullptr; // Finally, save the transfer to mTransfer. mTransfer = transfer; transfer = nullptr; // While we were bringing up the progress dialog, we actually finished // processing the url. If that's the case then mStopRequestIssued will be // true and OnSaveComplete has been called. if (mStopRequestIssued && !mSaver && mTransfer) { NotifyTransfer(NS_OK); } return rv; } nsresult nsExternalAppHandler::CreateFailedTransfer(bool aIsPrivateBrowsing) { nsresult rv; nsCOMPtr transfer = do_CreateInstance(NS_TRANSFER_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); // If we don't have a download directory we're kinda screwed but it's OK // we'll still report the error via the prompter. nsCOMPtr pseudoFile; rv = GetDownloadDirectory(getter_AddRefs(pseudoFile), true); NS_ENSURE_SUCCESS(rv, rv); // Append the default suggested filename. If the user restarts the transfer // we will re-trigger a filename check anyway to ensure that it is unique. rv = pseudoFile->Append(mSuggestedFileName); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr pseudoTarget; rv = NS_NewFileURI(getter_AddRefs(pseudoTarget), pseudoFile); NS_ENSURE_SUCCESS(rv, rv); rv = transfer->Init(mSourceUrl, pseudoTarget, EmptyString(), mMimeInfo, mTimeDownloadStarted, nullptr, this, aIsPrivateBrowsing); NS_ENSURE_SUCCESS(rv, rv); // Our failed transfer is ready. mTransfer = transfer.forget(); return NS_OK; } nsresult nsExternalAppHandler::SaveDestinationAvailable(nsIFile * aFile) { if (aFile) ContinueSave(aFile); else Cancel(NS_BINDING_ABORTED); return NS_OK; } void nsExternalAppHandler::RequestSaveDestination(const nsAFlatString &aDefaultFile, const nsAFlatString &aFileExtension) { // Display the dialog // XXX Convert to use file picker? No, then embeddors could not do any sort of // "AutoDownload" w/o showing a prompt nsresult rv = NS_OK; if (!mDialog) { // Get helper app launcher dialog. mDialog = do_CreateInstance(NS_HELPERAPPLAUNCHERDLG_CONTRACTID, &rv); if (rv != NS_OK) { Cancel(NS_BINDING_ABORTED); return; } } // we want to explicitly unescape aDefaultFile b4 passing into the dialog. we can't unescape // it because the dialog is implemented by a JS component which doesn't have a window so no unescape routine is defined... // Now, be sure to keep |this| alive, and the dialog // If we don't do this, users that close the helper app dialog while the file // picker is up would cause Cancel() to be called, and the dialog would be // released, which would release this object too, which would crash. // See Bug 249143 RefPtr kungFuDeathGrip(this); nsCOMPtr dlg(mDialog); rv = dlg->PromptForSaveToFileAsync(this, GetDialogParent(), aDefaultFile.get(), aFileExtension.get(), mForceSave); if (NS_FAILED(rv)) { Cancel(NS_BINDING_ABORTED); } } // SaveToDisk should only be called by the helper app dialog which allows // the user to say launch with application or save to disk. It doesn't actually // perform the save, it just prompts for the destination file name. NS_IMETHODIMP nsExternalAppHandler::SaveToDisk(nsIFile * aNewFileLocation, bool aRememberThisPreference) { if (mCanceled) return NS_OK; mMimeInfo->SetPreferredAction(nsIMIMEInfo::saveToDisk); if (!aNewFileLocation) { if (mSuggestedFileName.IsEmpty()) RequestSaveDestination(mTempLeafName, mTempFileExtension); else { nsAutoString fileExt; int32_t pos = mSuggestedFileName.RFindChar('.'); if (pos >= 0) mSuggestedFileName.Right(fileExt, mSuggestedFileName.Length() - pos); if (fileExt.IsEmpty()) fileExt = mTempFileExtension; RequestSaveDestination(mSuggestedFileName, fileExt); } } else { ContinueSave(aNewFileLocation); } return NS_OK; } nsresult nsExternalAppHandler::ContinueSave(nsIFile * aNewFileLocation) { if (mCanceled) return NS_OK; NS_PRECONDITION(aNewFileLocation, "Must be called with a non-null file"); nsresult rv = NS_OK; nsCOMPtr fileToUse = do_QueryInterface(aNewFileLocation); mFinalFileDestination = do_QueryInterface(fileToUse); // Move what we have in the final directory, but append .part // to it, to indicate that it's unfinished. Do not call SetTarget on the // saver if we are done (Finish has been called) but OnSaverComplete has not // been called. if (mFinalFileDestination && mSaver && !mStopRequestIssued) { nsCOMPtr movedFile; mFinalFileDestination->Clone(getter_AddRefs(movedFile)); if (movedFile) { // Get the old leaf name and append .part to it nsAutoString name; mFinalFileDestination->GetLeafName(name); name.AppendLiteral(".part"); movedFile->SetLeafName(name); rv = mSaver->SetTarget(movedFile, true); if (NS_FAILED(rv)) { nsAutoString path; mTempFile->GetPath(path); SendStatusChange(kWriteError, rv, nullptr, path); Cancel(rv); return NS_OK; } mTempFile = movedFile; } } // The helper app dialog has told us what to do and we have a final file // destination. rv = CreateTransfer(); // If we fail to create the transfer, Cancel. if (NS_FAILED(rv)) { Cancel(rv); return rv; } // now that the user has chosen the file location to save to, it's okay to fire the refresh tag // if there is one. We don't want to do this before the save as dialog goes away because this dialog // is modal and we do bad things if you try to load a web page in the underlying window while a modal // dialog is still up. ProcessAnyRefreshTags(); return NS_OK; } // LaunchWithApplication should only be called by the helper app dialog which // allows the user to say launch with application or save to disk. It doesn't // actually perform launch with application. NS_IMETHODIMP nsExternalAppHandler::LaunchWithApplication(nsIFile * aApplication, bool aRememberThisPreference) { if (mCanceled) return NS_OK; // user has chosen to launch using an application, fire any refresh tags now... ProcessAnyRefreshTags(); if (mMimeInfo && aApplication) { PlatformLocalHandlerApp_t *handlerApp = new PlatformLocalHandlerApp_t(EmptyString(), aApplication); mMimeInfo->SetPreferredApplicationHandler(handlerApp); } // Now check if the file is local, in which case we won't bother with saving // it to a temporary directory and just launch it from where it is nsCOMPtr fileUrl(do_QueryInterface(mSourceUrl)); if (fileUrl && mIsFileChannel) { Cancel(NS_BINDING_ABORTED); nsCOMPtr file; nsresult rv = fileUrl->GetFile(getter_AddRefs(file)); if (NS_SUCCEEDED(rv)) { rv = mMimeInfo->LaunchWithFile(file); if (NS_SUCCEEDED(rv)) return NS_OK; } nsAutoString path; if (file) file->GetPath(path); // If we get here, an error happened SendStatusChange(kLaunchError, rv, nullptr, path); return rv; } // Now that the user has elected to launch the downloaded file with a helper // app, we're justified in removing the 'salted' name. We'll rename to what // was specified in mSuggestedFileName after the download is done prior to // launching the helper app. So that any existing file of that name won't be // overwritten we call CreateUnique(). Also note that we use the same // directory as originally downloaded so nsDownload can rename in place // later. nsCOMPtr fileToUse; (void) GetDownloadDirectory(getter_AddRefs(fileToUse)); if (mSuggestedFileName.IsEmpty()) { // Keep using the leafname of the temp file, since we're just starting a helper mSuggestedFileName = mTempLeafName; } #ifdef XP_WIN fileToUse->Append(mSuggestedFileName + mTempFileExtension); #else fileToUse->Append(mSuggestedFileName); #endif nsresult rv = fileToUse->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600); if(NS_SUCCEEDED(rv)) { mFinalFileDestination = do_QueryInterface(fileToUse); // launch the progress window now that the user has picked the desired action. rv = CreateTransfer(); if (NS_FAILED(rv)) { Cancel(rv); } } else { // Cancel the download and report an error. We do not want to end up in // a state where it appears that we have a normal download that is // pointing to a file that we did not actually create. nsAutoString path; mTempFile->GetPath(path); SendStatusChange(kWriteError, rv, nullptr, path); Cancel(rv); } return rv; } NS_IMETHODIMP nsExternalAppHandler::Cancel(nsresult aReason) { NS_ENSURE_ARG(NS_FAILED(aReason)); if (mCanceled) { return NS_OK; } mCanceled = true; if (mSaver) { // We are still writing to the target file. Give the saver a chance to // close the target file, then notify the transfer object if necessary in // the OnSaveComplete callback. mSaver->Finish(aReason); mSaver = nullptr; } else { if (mStopRequestIssued && mTempFile) { // This branch can only happen when the user cancels the helper app dialog // when the request has completed. The temp file has to be removed here, // because mSaver has been released at that time with the temp file left. (void)mTempFile->Remove(false); } // Notify the transfer object that the download has been canceled, if the // user has already chosen an action and we didn't notify already. if (mTransfer) { NotifyTransfer(aReason); } } // Break our reference cycle with the helper app dialog (set up in // OnStartRequest) mDialog = nullptr; mRequest = nullptr; // Release the listener, to break the reference cycle with it (we are the // observer of the listener). mDialogProgressListener = nullptr; return NS_OK; } void nsExternalAppHandler::ProcessAnyRefreshTags() { // one last thing, try to see if the original window context supports a refresh interface... // Sometimes, when you download content that requires an external handler, there is // a refresh header associated with the download. This refresh header points to a page // the content provider wants the user to see after they download the content. How do we // pass this refresh information back to the caller? For now, try to get the refresh URI // interface. If the window context where the request originated came from supports this // then we can force it to process the refresh information (if there is any) from this channel. if (mContentContext && mOriginalChannel) { nsCOMPtr refreshHandler (do_GetInterface(mContentContext)); if (refreshHandler) { refreshHandler->SetupRefreshURI(mOriginalChannel); } mOriginalChannel = nullptr; } } bool nsExternalAppHandler::GetNeverAskFlagFromPref(const char * prefName, const char * aContentType) { // Search the obsolete pref strings. nsAdoptingCString prefCString = Preferences::GetCString(prefName); if (prefCString.IsEmpty()) { // Default is true, if not found in the pref string. return true; } NS_UnescapeURL(prefCString); nsACString::const_iterator start, end; prefCString.BeginReading(start); prefCString.EndReading(end); return !CaseInsensitiveFindInReadable(nsDependentCString(aContentType), start, end); } nsresult nsExternalAppHandler::MaybeCloseWindow() { nsCOMPtr window = do_GetInterface(mContentContext); NS_ENSURE_STATE(window); if (mShouldCloseWindow) { // Reset the window context to the opener window so that the dependent // dialogs have a parent nsCOMPtr opener = window->GetOpener(); if (opener && !opener->Closed()) { mContentContext = do_GetInterface(opener); // Now close the old window. Do it on a timer so that we don't run // into issues trying to close the window before it has fully opened. NS_ASSERTION(!mTimer, "mTimer was already initialized once!"); mTimer = do_CreateInstance("@mozilla.org/timer;1"); if (!mTimer) { return NS_ERROR_FAILURE; } mTimer->InitWithCallback(this, 0, nsITimer::TYPE_ONE_SHOT); mWindowToClose = window; } } return NS_OK; } NS_IMETHODIMP nsExternalAppHandler::Notify(nsITimer* timer) { NS_ASSERTION(mWindowToClose, "No window to close after timer fired"); mWindowToClose->Close(); mWindowToClose = nullptr; mTimer = nullptr; return NS_OK; } ////////////////////////////////////////////////////////////////////////////////////////////////////////////// // The following section contains our nsIMIMEService implementation and related methods. // ////////////////////////////////////////////////////////////////////////////////////////////////////////////// // nsIMIMEService methods NS_IMETHODIMP nsExternalHelperAppService::GetFromTypeAndExtension(const nsACString& aMIMEType, const nsACString& aFileExt, nsIMIMEInfo **_retval) { NS_PRECONDITION(!aMIMEType.IsEmpty() || !aFileExt.IsEmpty(), "Give me something to work with"); LOG(("Getting mimeinfo from type '%s' ext '%s'\n", PromiseFlatCString(aMIMEType).get(), PromiseFlatCString(aFileExt).get())); *_retval = nullptr; // OK... we need a type. Get one. nsAutoCString typeToUse(aMIMEType); if (typeToUse.IsEmpty()) { nsresult rv = GetTypeFromExtension(aFileExt, typeToUse); if (NS_FAILED(rv)) return NS_ERROR_NOT_AVAILABLE; } // We promise to only send lower case mime types to the OS ToLowerCase(typeToUse); // (1) Ask the OS for a mime info bool found; *_retval = GetMIMEInfoFromOS(typeToUse, aFileExt, &found).take(); LOG(("OS gave back 0x%p - found: %i\n", *_retval, found)); // If we got no mimeinfo, something went wrong. Probably lack of memory. if (!*_retval) return NS_ERROR_OUT_OF_MEMORY; // (2) Now, let's see if we can find something in our datastore // This will not overwrite the OS information that interests us // (i.e. default application, default app. description) nsresult rv; nsCOMPtr handlerSvc = do_GetService(NS_HANDLERSERVICE_CONTRACTID); if (handlerSvc) { bool hasHandler = false; (void) handlerSvc->Exists(*_retval, &hasHandler); if (hasHandler) { rv = handlerSvc->FillHandlerInfo(*_retval, EmptyCString()); LOG(("Data source: Via type: retval 0x%08x\n", rv)); } else { rv = NS_ERROR_NOT_AVAILABLE; } found = found || NS_SUCCEEDED(rv); if (!found || NS_FAILED(rv)) { // No type match, try extension match if (!aFileExt.IsEmpty()) { nsAutoCString overrideType; rv = handlerSvc->GetTypeFromExtension(aFileExt, overrideType); if (NS_SUCCEEDED(rv) && !overrideType.IsEmpty()) { // We can't check handlerSvc->Exists() here, because we have a // overideType. That's ok, it just results in some console noise. // (If there's no handler for the override type, it throws) rv = handlerSvc->FillHandlerInfo(*_retval, overrideType); LOG(("Data source: Via ext: retval 0x%08x\n", rv)); found = found || NS_SUCCEEDED(rv); } } } } // (3) No match yet. Ask extras. if (!found) { rv = NS_ERROR_FAILURE; #ifdef XP_WIN /* XXX Gross hack to wallpaper over the most common Win32 * extension issues caused by the fix for bug 116938. See bug * 120327, comment 271 for why this is needed. Not even sure we * want to remove this once we have fixed all this stuff to work * right; any info we get from extras on this type is pretty much * useless.... */ if (!typeToUse.Equals(APPLICATION_OCTET_STREAM, nsCaseInsensitiveCStringComparator())) #endif rv = FillMIMEInfoForMimeTypeFromExtras(typeToUse, *_retval); LOG(("Searched extras (by type), rv 0x%08X\n", rv)); // If that didn't work out, try file extension from extras if (NS_FAILED(rv) && !aFileExt.IsEmpty()) { rv = FillMIMEInfoForExtensionFromExtras(aFileExt, *_retval); LOG(("Searched extras (by ext), rv 0x%08X\n", rv)); } // If that still didn't work, set the file description to "ext File" if (NS_FAILED(rv) && !aFileExt.IsEmpty()) { // XXXzpao This should probably be localized nsAutoCString desc(aFileExt); desc.AppendLiteral(" File"); (*_retval)->SetDescription(NS_ConvertASCIItoUTF16(desc)); LOG(("Falling back to 'File' file description\n")); } } // Finally, check if we got a file extension and if yes, if it is an // extension on the mimeinfo, in which case we want it to be the primary one if (!aFileExt.IsEmpty()) { bool matches = false; (*_retval)->ExtensionExists(aFileExt, &matches); LOG(("Extension '%s' matches mime info: %i\n", PromiseFlatCString(aFileExt).get(), matches)); if (matches) (*_retval)->SetPrimaryExtension(aFileExt); } if (LOG_ENABLED()) { nsAutoCString type; (*_retval)->GetMIMEType(type); nsAutoCString ext; (*_retval)->GetPrimaryExtension(ext); LOG(("MIME Info Summary: Type '%s', Primary Ext '%s'\n", type.get(), ext.get())); } return NS_OK; } NS_IMETHODIMP nsExternalHelperAppService::GetTypeFromExtension(const nsACString& aFileExt, nsACString& aContentType) { // OK. We want to try the following sources of mimetype information, in this order: // 1. defaultMimeEntries array // 2. OS-provided information // 3. our "extras" array // 4. Information from plugins // 5. The "ext-to-type-mapping" category // Note that, we are intentionally not looking at the handler service, because // that can be affected by websites, which leads to undesired behavior. // Early return if called with an empty extension parameter if (aFileExt.IsEmpty()) { return NS_ERROR_NOT_AVAILABLE; } // First of all, check our default entries for (auto& entry : defaultMimeEntries) { if (aFileExt.LowerCaseEqualsASCII(entry.mFileExtension)) { aContentType = entry.mMimeType; return NS_OK; } } // Ask OS. if (GetMIMETypeFromOSForExtension(aFileExt, aContentType)) { return NS_OK; } // Check extras array. bool found = GetTypeFromExtras(aFileExt, aContentType); if (found) { return NS_OK; } // Try the plugins RefPtr pluginHost = nsPluginHost::GetInst(); if (pluginHost && pluginHost->HavePluginForExtension(aFileExt, aContentType)) { return NS_OK; } // Let's see if an extension added something nsCOMPtr catMan( do_GetService("@mozilla.org/categorymanager;1")); if (catMan) { // The extension in the category entry is always stored as lowercase nsAutoCString lowercaseFileExt(aFileExt); ToLowerCase(lowercaseFileExt); // Read the MIME type from the category entry, if available nsXPIDLCString type; nsresult rv = catMan->GetCategoryEntry("ext-to-type-mapping", lowercaseFileExt.get(), getter_Copies(type)); if (NS_SUCCEEDED(rv)) { aContentType = type; return NS_OK; } } return NS_ERROR_NOT_AVAILABLE; } NS_IMETHODIMP nsExternalHelperAppService::GetPrimaryExtension(const nsACString& aMIMEType, const nsACString& aFileExt, nsACString& _retval) { NS_ENSURE_ARG(!aMIMEType.IsEmpty()); nsCOMPtr mi; nsresult rv = GetFromTypeAndExtension(aMIMEType, aFileExt, getter_AddRefs(mi)); if (NS_FAILED(rv)) return rv; return mi->GetPrimaryExtension(_retval); } NS_IMETHODIMP nsExternalHelperAppService::GetTypeFromURI(nsIURI *aURI, nsACString& aContentType) { NS_ENSURE_ARG_POINTER(aURI); nsresult rv = NS_ERROR_NOT_AVAILABLE; aContentType.Truncate(); // First look for a file to use. If we have one, we just use that. nsCOMPtr fileUrl = do_QueryInterface(aURI); if (fileUrl) { nsCOMPtr file; rv = fileUrl->GetFile(getter_AddRefs(file)); if (NS_SUCCEEDED(rv)) { rv = GetTypeFromFile(file, aContentType); if (NS_SUCCEEDED(rv)) { // we got something! return rv; } } } // Now try to get an nsIURL so we don't have to do our own parsing nsCOMPtr url = do_QueryInterface(aURI); if (url) { nsAutoCString ext; rv = url->GetFileExtension(ext); if (NS_FAILED(rv)) return rv; if (ext.IsEmpty()) return NS_ERROR_NOT_AVAILABLE; UnescapeFragment(ext, url, ext); return GetTypeFromExtension(ext, aContentType); } // no url, let's give the raw spec a shot nsAutoCString specStr; rv = aURI->GetSpec(specStr); if (NS_FAILED(rv)) return rv; UnescapeFragment(specStr, aURI, specStr); // find the file extension (if any) int32_t extLoc = specStr.RFindChar('.'); int32_t specLength = specStr.Length(); if (-1 != extLoc && extLoc != specLength - 1 && // nothing over 20 chars long can be sanely considered an // extension.... Dat dere would be just data. specLength - extLoc < 20) { return GetTypeFromExtension(Substring(specStr, extLoc + 1), aContentType); } // We found no information; say so. return NS_ERROR_NOT_AVAILABLE; } NS_IMETHODIMP nsExternalHelperAppService::GetTypeFromFile(nsIFile* aFile, nsACString& aContentType) { NS_ENSURE_ARG_POINTER(aFile); nsresult rv; // Get the Extension nsAutoString fileName; rv = aFile->GetLeafName(fileName); if (NS_FAILED(rv)) return rv; nsAutoCString fileExt; if (!fileName.IsEmpty()) { int32_t len = fileName.Length(); for (int32_t i = len; i >= 0; i--) { if (fileName[i] == char16_t('.')) { CopyUTF16toUTF8(fileName.get() + i + 1, fileExt); break; } } } if (fileExt.IsEmpty()) return NS_ERROR_FAILURE; return GetTypeFromExtension(fileExt, aContentType); } nsresult nsExternalHelperAppService::FillMIMEInfoForMimeTypeFromExtras( const nsACString& aContentType, nsIMIMEInfo * aMIMEInfo) { NS_ENSURE_ARG( aMIMEInfo ); NS_ENSURE_ARG( !aContentType.IsEmpty() ); // Look for default entry with matching mime type. nsAutoCString MIMEType(aContentType); ToLowerCase(MIMEType); int32_t numEntries = ArrayLength(extraMimeEntries); for (int32_t index = 0; index < numEntries; index++) { if ( MIMEType.Equals(extraMimeEntries[index].mMimeType) ) { // This is the one. Set attributes appropriately. aMIMEInfo->SetFileExtensions(nsDependentCString(extraMimeEntries[index].mFileExtensions)); aMIMEInfo->SetDescription(NS_ConvertASCIItoUTF16(extraMimeEntries[index].mDescription)); return NS_OK; } } return NS_ERROR_NOT_AVAILABLE; } nsresult nsExternalHelperAppService::FillMIMEInfoForExtensionFromExtras( const nsACString& aExtension, nsIMIMEInfo * aMIMEInfo) { nsAutoCString type; bool found = GetTypeFromExtras(aExtension, type); if (!found) return NS_ERROR_NOT_AVAILABLE; return FillMIMEInfoForMimeTypeFromExtras(type, aMIMEInfo); } bool nsExternalHelperAppService::GetTypeFromExtras(const nsACString& aExtension, nsACString& aMIMEType) { NS_ASSERTION(!aExtension.IsEmpty(), "Empty aExtension parameter!"); // Look for default entry with matching extension. nsDependentCString::const_iterator start, end, iter; int32_t numEntries = ArrayLength(extraMimeEntries); for (int32_t index = 0; index < numEntries; index++) { nsDependentCString extList(extraMimeEntries[index].mFileExtensions); extList.BeginReading(start); extList.EndReading(end); iter = start; while (start != end) { FindCharInReadable(',', iter, end); if (Substring(start, iter).Equals(aExtension, nsCaseInsensitiveCStringComparator())) { aMIMEType = extraMimeEntries[index].mMimeType; return true; } if (iter != end) { ++iter; } start = iter; } } return false; } bool nsExternalHelperAppService::GetMIMETypeFromOSForExtension(const nsACString& aExtension, nsACString& aMIMEType) { bool found = false; nsCOMPtr mimeInfo = GetMIMEInfoFromOS(EmptyCString(), aExtension, &found); return found && mimeInfo && NS_SUCCEEDED(mimeInfo->GetMIMEType(aMIMEType)); }