diff options
Diffstat (limited to 'toolkit/components/pdfjs/content/PdfStreamConverter.sys.mjs')
| -rw-r--r-- | toolkit/components/pdfjs/content/PdfStreamConverter.sys.mjs | 1249 |
1 files changed, 1249 insertions, 0 deletions
diff --git a/toolkit/components/pdfjs/content/PdfStreamConverter.sys.mjs b/toolkit/components/pdfjs/content/PdfStreamConverter.sys.mjs new file mode 100644 index 0000000000..7f9eea1b45 --- /dev/null +++ b/toolkit/components/pdfjs/content/PdfStreamConverter.sys.mjs @@ -0,0 +1,1249 @@ +/* Copyright 2012 Mozilla Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +const PDFJS_EVENT_ID = "pdf.js.message"; +const PREF_PREFIX = "pdfjs"; +const PDF_VIEWER_ORIGIN = "resource://pdf.js"; +const PDF_VIEWER_WEB_PAGE = "resource://pdf.js/web/viewer.html"; +const MAX_NUMBER_OF_PREFS = 50; +const MAX_STRING_PREF_LENGTH = 128; +const PDF_CONTENT_TYPE = "application/pdf"; + +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; +import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs"; + +const lazy = {}; +ChromeUtils.defineESModuleGetters(lazy, { + AsyncPrefs: "resource://gre/modules/AsyncPrefs.sys.mjs", + NetworkManager: "resource://pdf.js/PdfJsNetwork.sys.mjs", + PdfJs: "resource://pdf.js/PdfJs.sys.mjs", + PdfJsTelemetry: "resource://pdf.js/PdfJsTelemetry.sys.mjs", + PdfSandbox: "resource://pdf.js/PdfSandbox.sys.mjs", + PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs", +}); +ChromeUtils.defineModuleGetter( + lazy, + "NetUtil", + "resource://gre/modules/NetUtil.jsm" +); + +var Svc = {}; +XPCOMUtils.defineLazyServiceGetter( + Svc, + "mime", + "@mozilla.org/mime;1", + "nsIMIMEService" +); +XPCOMUtils.defineLazyServiceGetter( + Svc, + "handlers", + "@mozilla.org/uriloader/handler-service;1", + "nsIHandlerService" +); + +XPCOMUtils.defineLazyGetter(lazy, "gOurBinary", () => { + let file = Services.dirsvc.get("XREExeF", Ci.nsIFile); + // Make sure to get the .app on macOS + if (AppConstants.platform == "macosx") { + while (file) { + if (/\.app\/?$/i.test(file.leafName)) { + break; + } + file = file.parent; + } + } + return file; +}); + +function getBoolPref(pref, def) { + try { + return Services.prefs.getBoolPref(pref); + } catch (ex) { + return def; + } +} + +function getIntPref(pref, def) { + try { + return Services.prefs.getIntPref(pref); + } catch (ex) { + return def; + } +} + +function getStringPref(pref, def) { + try { + return Services.prefs.getStringPref(pref); + } catch (ex) { + return def; + } +} + +function log(aMsg) { + if (!getBoolPref(PREF_PREFIX + ".pdfBugEnabled", false)) { + return; + } + var msg = "PdfStreamConverter.js: " + (aMsg.join ? aMsg.join("") : aMsg); + Services.console.logStringMessage(msg); + dump(msg + "\n"); +} + +function getDOMWindow(aChannel, aPrincipal) { + var requestor = aChannel.notificationCallbacks + ? aChannel.notificationCallbacks + : aChannel.loadGroup.notificationCallbacks; + var win = requestor.getInterface(Ci.nsIDOMWindow); + // Ensure the window wasn't navigated to something that is not PDF.js. + if (!win.document.nodePrincipal.equals(aPrincipal)) { + return null; + } + return win; +} + +function getActor(window) { + try { + const actorName = + AppConstants.platform === "android" ? "GeckoViewPdfjs" : "Pdfjs"; + return window.windowGlobalChild.getActor(actorName); + } catch (ex) { + return null; + } +} + +function getLocalizedStrings(path) { + var stringBundle = Services.strings.createBundle( + "chrome://pdf.js/locale/" + path + ); + + var map = {}; + for (let string of stringBundle.getSimpleEnumeration()) { + var key = string.key, + property = "textContent"; + var i = key.lastIndexOf("."); + if (i >= 0) { + property = key.substring(i + 1); + key = key.substring(0, i); + } + if (!(key in map)) { + map[key] = {}; + } + map[key][property] = string.value; + } + return map; +} + +function isValidMatchesCount(data) { + if (typeof data !== "object" || data === null) { + return false; + } + const { current, total } = data; + if ( + typeof total !== "number" || + total < 0 || + typeof current !== "number" || + current < 0 || + current > total + ) { + return false; + } + return true; +} + +// PDF data storage +function PdfDataListener(length) { + this.length = length; // less than 0, if length is unknown + this.buffers = []; + this.loaded = 0; +} + +PdfDataListener.prototype = { + append: function PdfDataListener_append(chunk) { + // In most of the cases we will pass data as we receive it, but at the + // beginning of the loading we may accumulate some data. + this.buffers.push(chunk); + this.loaded += chunk.length; + if (this.length >= 0 && this.length < this.loaded) { + this.length = -1; // reset the length, server is giving incorrect one + } + this.onprogress(this.loaded, this.length >= 0 ? this.length : void 0); + }, + readData: function PdfDataListener_readData() { + if (this.buffers.length === 0) { + return null; + } + if (this.buffers.length === 1) { + return this.buffers.pop(); + } + // There are multiple buffers that need to be combined into a single + // buffer. + let combinedLength = 0; + for (let buffer of this.buffers) { + combinedLength += buffer.length; + } + let combinedArray = new Uint8Array(combinedLength); + let writeOffset = 0; + while (this.buffers.length) { + let buffer = this.buffers.shift(); + combinedArray.set(buffer, writeOffset); + writeOffset += buffer.length; + } + return combinedArray; + }, + get isDone() { + return !!this.isDataReady; + }, + finish: function PdfDataListener_finish() { + this.isDataReady = true; + if (this.oncompleteCallback) { + this.oncompleteCallback(this.readData()); + } + }, + error: function PdfDataListener_error(errorCode) { + this.errorCode = errorCode; + if (this.oncompleteCallback) { + this.oncompleteCallback(null, errorCode); + } + }, + onprogress() {}, + get oncomplete() { + return this.oncompleteCallback; + }, + set oncomplete(value) { + this.oncompleteCallback = value; + if (this.isDataReady) { + value(this.readData()); + } + if (this.errorCode) { + value(null, this.errorCode); + } + }, +}; + +/** + * All the privileged actions. + */ +class ChromeActions { + constructor(domWindow, contentDispositionFilename) { + this.domWindow = domWindow; + this.contentDispositionFilename = contentDispositionFilename; + this.sandbox = null; + this.unloadListener = null; + } + + createSandbox(data, sendResponse) { + function sendResp(res) { + if (sendResponse) { + sendResponse(res); + } + return res; + } + + if (!getBoolPref(PREF_PREFIX + ".enableScripting", false)) { + return sendResp(false); + } + + if (this.sandbox !== null) { + return sendResp(true); + } + + try { + this.sandbox = new lazy.PdfSandbox(this.domWindow, data); + } catch (err) { + // If there's an error here, it means that something is really wrong + // on pdf.js side during sandbox initialization phase. + console.error(err); + return sendResp(false); + } + + this.unloadListener = () => { + this.destroySandbox(); + }; + this.domWindow.addEventListener("unload", this.unloadListener); + + return sendResp(true); + } + + dispatchEventInSandbox(event) { + if (this.sandbox) { + this.sandbox.dispatchEvent(event); + } + } + + dispatchAsyncEventInSandbox(event, sendResponse) { + this.dispatchEventInSandbox(event); + sendResponse(); + } + + destroySandbox() { + if (this.sandbox) { + this.domWindow.removeEventListener("unload", this.unloadListener); + this.sandbox.destroy(); + this.sandbox = null; + } + } + + isInPrivateBrowsing() { + return lazy.PrivateBrowsingUtils.isContentWindowPrivate(this.domWindow); + } + + getWindowOriginAttributes() { + try { + return this.domWindow.document.nodePrincipal.originAttributes; + } catch (err) { + return {}; + } + } + + download(data, sendResponse) { + const { originalUrl, options } = data; + const blobUrl = data.blobUrl || originalUrl; + let { filename } = data; + if ( + typeof filename !== "string" || + (!/\.pdf$/i.test(filename) && !data.isAttachment) + ) { + filename = "document.pdf"; + } + + const actor = getActor(this.domWindow); + actor.sendAsyncMessage("PDFJS:Parent:saveURL", { + blobUrl, + originalUrl, + filename, + options: options || {}, + }); + } + + getLocale() { + return Services.locale.requestedLocale || "en-US"; + } + + getStrings() { + try { + // Lazy initialization of localizedStrings + this.localizedStrings ||= getLocalizedStrings("viewer.properties"); + + return this.localizedStrings; + } catch (e) { + log("Unable to retrieve localized strings: " + e); + return null; + } + } + + supportsIntegratedFind() { + // Integrated find is only supported when we're not in a frame + return this.domWindow.windowGlobalChild.browsingContext.parent === null; + } + + supportsDocumentFonts() { + var prefBrowser = getIntPref("browser.display.use_document_fonts", 1); + var prefGfx = getBoolPref("gfx.downloadable_fonts.enabled", true); + return !!prefBrowser && prefGfx; + } + + supportsPinchToZoom() { + return getBoolPref("apz.allow_zooming", true); + } + + supportedMouseWheelZoomModifierKeys() { + return { + ctrlKey: getIntPref("mousewheel.with_control.action", 3) === 3, + metaKey: getIntPref("mousewheel.with_meta.action", 1) === 3, + }; + } + + getCanvasMaxArea() { + return getIntPref("gfx.max-alloc-size", 500000000); + } + + isInAutomation() { + return Cu.isInAutomation; + } + + isMobile() { + return AppConstants.platform === "android"; + } + + getNimbusExperimentData(_data, sendResponse) { + if (!this.isMobile()) { + sendResponse(null); + return; + } + const actor = getActor(this.domWindow); + actor.sendAsyncMessage("PDFJS:Parent:getNimbus"); + Services.obs.addObserver( + { + observe(aSubject, aTopic, aData) { + if (aTopic === "pdfjs-getNimbus") { + Services.obs.removeObserver(this, aTopic); + sendResponse(aSubject && JSON.stringify(aSubject.wrappedJSObject)); + } + }, + }, + "pdfjs-getNimbus" + ); + } + + reportTelemetry(data) { + const probeInfo = JSON.parse(data); + const { type } = probeInfo; + switch (type) { + case "pageInfo": + lazy.PdfJsTelemetry.onTimeToView(probeInfo.timestamp); + break; + case "editing": + lazy.PdfJsTelemetry.onEditing(probeInfo.data.type); + break; + case "buttons": + case "gv-buttons": + const id = probeInfo.data.id.replace( + /([A-Z])/g, + c => `_${c.toLowerCase()}` + ); + if (type === "buttons") { + lazy.PdfJsTelemetry.onButtons(id); + } else { + lazy.PdfJsTelemetry.onGeckoview(id); + } + break; + } + } + + /** + * @param {Object} args - Object with `featureId` and `url` properties. + * @param {function} sendResponse - Callback function. + */ + fallback(args, sendResponse) { + sendResponse(false); + } + + updateFindControlState(data) { + if (!this.supportsIntegratedFind()) { + return; + } + // Verify what we're sending to the findbar. + var result = data.result; + var findPrevious = data.findPrevious; + var findPreviousType = typeof findPrevious; + if ( + typeof result !== "number" || + result < 0 || + result > 3 || + (findPreviousType !== "undefined" && findPreviousType !== "boolean") + ) { + return; + } + // Allow the `matchesCount` property to be optional, and ensure that + // it's valid before including it in the data sent to the findbar. + let matchesCount = null; + if (isValidMatchesCount(data.matchesCount)) { + matchesCount = data.matchesCount; + } + // Same for the `rawQuery` property. + let rawQuery = null; + if (typeof data.rawQuery === "string") { + rawQuery = data.rawQuery; + } + + let actor = getActor(this.domWindow); + actor?.sendAsyncMessage("PDFJS:Parent:updateControlState", { + result, + findPrevious, + matchesCount, + rawQuery, + }); + } + + updateFindMatchesCount(data) { + if (!this.supportsIntegratedFind()) { + return; + } + // Verify what we're sending to the findbar. + if (!isValidMatchesCount(data)) { + return; + } + + let actor = getActor(this.domWindow); + actor?.sendAsyncMessage("PDFJS:Parent:updateMatchesCount", data); + } + + setPreferences(prefs, sendResponse) { + var defaultBranch = Services.prefs.getDefaultBranch(PREF_PREFIX + "."); + var numberOfPrefs = 0; + var prefValue, prefName; + for (var key in prefs) { + if (++numberOfPrefs > MAX_NUMBER_OF_PREFS) { + log( + "setPreferences - Exceeded the maximum number of preferences " + + "that is allowed to be set at once." + ); + break; + } else if (!defaultBranch.getPrefType(key)) { + continue; + } + prefValue = prefs[key]; + prefName = PREF_PREFIX + "." + key; + switch (typeof prefValue) { + case "boolean": + lazy.AsyncPrefs.set(prefName, prefValue); + break; + case "number": + lazy.AsyncPrefs.set(prefName, prefValue); + break; + case "string": + if (prefValue.length > MAX_STRING_PREF_LENGTH) { + log( + "setPreferences - Exceeded the maximum allowed length " + + "for a string preference." + ); + } else { + lazy.AsyncPrefs.set(prefName, prefValue); + } + break; + } + } + if (sendResponse) { + sendResponse(true); + } + } + + getPreferences(prefs, sendResponse) { + var defaultBranch = Services.prefs.getDefaultBranch(PREF_PREFIX + "."); + var currentPrefs = {}, + numberOfPrefs = 0; + var prefValue, prefName; + for (var key in prefs) { + if (++numberOfPrefs > MAX_NUMBER_OF_PREFS) { + log( + "getPreferences - Exceeded the maximum number of preferences " + + "that is allowed to be fetched at once." + ); + break; + } else if (!defaultBranch.getPrefType(key)) { + continue; + } + prefValue = prefs[key]; + prefName = PREF_PREFIX + "." + key; + switch (typeof prefValue) { + case "boolean": + currentPrefs[key] = getBoolPref(prefName, prefValue); + break; + case "number": + currentPrefs[key] = getIntPref(prefName, prefValue); + break; + case "string": + currentPrefs[key] = getStringPref(prefName, prefValue); + break; + } + } + let result = JSON.stringify(currentPrefs); + if (sendResponse) { + sendResponse(result); + } + return result; + } + + /** + * Set the different editor states in order to be able to update the context + * menu. + * @param {Object} details + */ + updateEditorStates({ details }) { + const doc = this.domWindow.document; + if (!doc.editorStates) { + doc.editorStates = { + isEditing: false, + isEmpty: true, + hasSomethingToUndo: false, + hasSomethingToRedo: false, + hasSelectedEditor: false, + }; + } + const { editorStates } = doc; + for (const [key, value] of Object.entries(details)) { + if (typeof value === "boolean" && key in editorStates) { + editorStates[key] = value; + } + } + } +} + +/** + * This is for range requests. + */ +class RangedChromeActions extends ChromeActions { + constructor( + domWindow, + contentDispositionFilename, + originalRequest, + rangeEnabled, + streamingEnabled, + dataListener + ) { + super(domWindow, contentDispositionFilename); + this.dataListener = dataListener; + this.originalRequest = originalRequest; + this.rangeEnabled = rangeEnabled; + this.streamingEnabled = streamingEnabled; + + this.pdfUrl = originalRequest.URI.spec; + this.contentLength = originalRequest.contentLength; + + // Pass all the headers from the original request through + var httpHeaderVisitor = { + headers: {}, + visitHeader(aHeader, aValue) { + if (aHeader === "Range") { + // When loading the PDF from cache, firefox seems to set the Range + // request header to fetch only the unfetched portions of the file + // (e.g. 'Range: bytes=1024-'). However, we want to set this header + // manually to fetch the PDF in chunks. + return; + } + this.headers[aHeader] = aValue; + }, + }; + if (originalRequest.visitRequestHeaders) { + originalRequest.visitRequestHeaders(httpHeaderVisitor); + } + + var self = this; + var xhr_onreadystatechange = function xhr_onreadystatechange() { + if (this.readyState === 1) { + // LOADING + var netChannel = this.channel; + // override this XMLHttpRequest's OriginAttributes with our cached parent window's + // OriginAttributes, as we are currently running under the SystemPrincipal + this.setOriginAttributes(self.getWindowOriginAttributes()); + if ( + "nsIPrivateBrowsingChannel" in Ci && + netChannel instanceof Ci.nsIPrivateBrowsingChannel + ) { + var docIsPrivate = self.isInPrivateBrowsing(); + netChannel.setPrivate(docIsPrivate); + } + } + }; + var getXhr = function getXhr() { + var xhr = new XMLHttpRequest(); + xhr.addEventListener("readystatechange", xhr_onreadystatechange); + return xhr; + }; + + this.networkManager = new lazy.NetworkManager(this.pdfUrl, { + httpHeaders: httpHeaderVisitor.headers, + getXhr, + }); + + // If we are in range request mode, this means we manually issued xhr + // requests, which we need to abort when we leave the page + domWindow.addEventListener("unload", function unload(e) { + domWindow.removeEventListener(e.type, unload); + self.abortLoading(); + }); + } + + initPassiveLoading() { + let data, done; + if (!this.streamingEnabled) { + this.originalRequest.cancel(Cr.NS_BINDING_ABORTED); + this.originalRequest = null; + data = this.dataListener.readData(); + done = this.dataListener.isDone; + this.dataListener = null; + } else { + data = this.dataListener.readData(); + done = this.dataListener.isDone; + + this.dataListener.onprogress = (loaded, total) => { + const chunk = this.dataListener.readData(); + + this.domWindow.postMessage( + { + pdfjsLoadAction: "progressiveRead", + loaded, + total, + chunk, + }, + PDF_VIEWER_ORIGIN, + chunk ? [chunk.buffer] : undefined + ); + }; + this.dataListener.oncomplete = () => { + if (!done && this.dataListener.isDone) { + this.domWindow.postMessage( + { + pdfjsLoadAction: "progressiveDone", + }, + PDF_VIEWER_ORIGIN + ); + } + this.dataListener = null; + }; + } + + this.domWindow.postMessage( + { + pdfjsLoadAction: "supportsRangedLoading", + rangeEnabled: this.rangeEnabled, + streamingEnabled: this.streamingEnabled, + pdfUrl: this.pdfUrl, + length: this.contentLength, + data, + done, + filename: this.contentDispositionFilename, + }, + PDF_VIEWER_ORIGIN, + data ? [data.buffer] : undefined + ); + + return true; + } + + requestDataRange(args) { + if (!this.rangeEnabled) { + return; + } + + var begin = args.begin; + var end = args.end; + var domWindow = this.domWindow; + // TODO(mack): Support error handler. We're not currently not handling + // errors from chrome code for non-range requests, so this doesn't + // seem high-pri + this.networkManager.requestRange(begin, end, { + onDone: function RangedChromeActions_onDone({ begin, chunk }) { + domWindow.postMessage( + { + pdfjsLoadAction: "range", + begin, + chunk, + }, + PDF_VIEWER_ORIGIN, + chunk ? [chunk.buffer] : undefined + ); + }, + onProgress: function RangedChromeActions_onProgress(evt) { + domWindow.postMessage( + { + pdfjsLoadAction: "rangeProgress", + loaded: evt.loaded, + }, + PDF_VIEWER_ORIGIN + ); + }, + }); + } + + abortLoading() { + this.networkManager.abortAllRequests(); + if (this.originalRequest) { + this.originalRequest.cancel(Cr.NS_BINDING_ABORTED); + this.originalRequest = null; + } + this.dataListener = null; + } +} + +/** + * This is for a single network stream. + */ +class StandardChromeActions extends ChromeActions { + constructor( + domWindow, + contentDispositionFilename, + originalRequest, + dataListener + ) { + super(domWindow, contentDispositionFilename); + this.originalRequest = originalRequest; + this.dataListener = dataListener; + } + + initPassiveLoading() { + if (!this.dataListener) { + return false; + } + + this.dataListener.onprogress = (loaded, total) => { + this.domWindow.postMessage( + { + pdfjsLoadAction: "progress", + loaded, + total, + }, + PDF_VIEWER_ORIGIN + ); + }; + + this.dataListener.oncomplete = (data, errorCode) => { + this.domWindow.postMessage( + { + pdfjsLoadAction: "complete", + data, + errorCode, + filename: this.contentDispositionFilename, + }, + PDF_VIEWER_ORIGIN, + data ? [data.buffer] : undefined + ); + + this.dataListener = null; + this.originalRequest = null; + }; + + return true; + } + + abortLoading() { + if (this.originalRequest) { + this.originalRequest.cancel(Cr.NS_BINDING_ABORTED); + this.originalRequest = null; + } + this.dataListener = null; + } +} + +/** + * Event listener to trigger chrome privileged code. + */ +class RequestListener { + constructor(actions) { + this.actions = actions; + } + + // Receive an event and synchronously or asynchronously responds. + receive(event) { + var message = event.target; + var doc = message.ownerDocument; + var action = event.detail.action; + var data = event.detail.data; + var sync = event.detail.sync; + var actions = this.actions; + if (!(action in actions)) { + log("Unknown action: " + action); + return; + } + var response; + if (sync) { + response = actions[action].call(this.actions, data); + event.detail.response = Cu.cloneInto(response, doc.defaultView); + } else { + if (!event.detail.responseExpected) { + doc.documentElement.removeChild(message); + response = null; + } else { + response = function sendResponse(aResponse) { + try { + var listener = doc.createEvent("CustomEvent"); + let detail = Cu.cloneInto({ response: aResponse }, doc.defaultView); + listener.initCustomEvent("pdf.js.response", true, false, detail); + return message.dispatchEvent(listener); + } catch (e) { + // doc is no longer accessible because the requestor is already + // gone. unloaded content cannot receive the response anyway. + return false; + } + }; + } + actions[action].call(this.actions, data, response); + } + } +} + +export function PdfStreamConverter() {} + +PdfStreamConverter.prototype = { + QueryInterface: ChromeUtils.generateQI([ + "nsIStreamConverter", + "nsIStreamListener", + "nsIRequestObserver", + ]), + + /* + * This component works as such: + * 1. asyncConvertData stores the listener + * 2. onStartRequest creates a new channel, streams the viewer + * 3. If range requests are supported: + * 3.1. Leave the request open until the viewer is ready to switch to + * range requests. + * + * If range rquests are not supported: + * 3.1. Read the stream as it's loaded in onDataAvailable to send + * to the viewer + * + * The convert function just returns the stream, it's just the synchronous + * version of asyncConvertData. + */ + + // nsIStreamConverter::convert + convert(aFromStream, aFromType, aToType, aCtxt) { + throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED); + }, + + // nsIStreamConverter::asyncConvertData + asyncConvertData(aFromType, aToType, aListener, aCtxt) { + if (aCtxt && aCtxt instanceof Ci.nsIChannel) { + aCtxt.QueryInterface(Ci.nsIChannel); + } + // We need to check if we're supposed to convert here, because not all + // asyncConvertData consumers will call getConvertedType first: + this.getConvertedType(aFromType, aCtxt); + + // Store the listener passed to us + this.listener = aListener; + }, + + _usableHandler(handlerInfo) { + let { preferredApplicationHandler } = handlerInfo; + if ( + !preferredApplicationHandler || + !(preferredApplicationHandler instanceof Ci.nsILocalHandlerApp) + ) { + return false; + } + preferredApplicationHandler.QueryInterface(Ci.nsILocalHandlerApp); + // We have an app, grab the executable + let { executable } = preferredApplicationHandler; + if (!executable) { + return false; + } + return !executable.equals(lazy.gOurBinary); + }, + + /* + * Check if the user wants to use PDF.js. Returns true if PDF.js should + * handle PDFs, and false if not. Will always return true on non-parent + * processes. + * + * If the user has selected to open PDFs with a helper app, and we are that + * helper app, or if the user has selected the OS default, and we are that + * OS default, reset the preference back to pdf.js . + * + */ + _validateAndMaybeUpdatePDFPrefs() { + let { processType, PROCESS_TYPE_DEFAULT } = Services.appinfo; + // If we're not in the parent, or are the default, then just say yes. + if (processType != PROCESS_TYPE_DEFAULT || lazy.PdfJs.cachedIsDefault()) { + return { shouldOpen: true }; + } + + // OK, PDF.js might not be the default. Find out if we've misled the user + // into making Firefox an external handler or if we're the OS default and + // Firefox is set to use the OS default: + let mime = Svc.mime.getFromTypeAndExtension(PDF_CONTENT_TYPE, "pdf"); + // The above might throw errors. We're deliberately letting those bubble + // back up, where they'll tell the stream converter not to use us. + + if (!mime) { + // This shouldn't happen, but we can't fix what isn't there. Assume + // we're OK to handle with PDF.js + return { shouldOpen: true }; + } + + const { saveToDisk, useHelperApp, useSystemDefault } = Ci.nsIHandlerInfo; + let { preferredAction, alwaysAskBeforeHandling } = mime; + // return this info so getConvertedType can use it. + let rv = { alwaysAskBeforeHandling, shouldOpen: false }; + // If the user has indicated they want to be asked or want to save to + // disk, we shouldn't render inline immediately: + if (alwaysAskBeforeHandling || preferredAction == saveToDisk) { + return rv; + } + // If we have usable helper app info, don't use PDF.js + if (preferredAction == useHelperApp && this._usableHandler(mime)) { + return rv; + } + // If we want the OS default and that's not Firefox, don't use PDF.js + if (preferredAction == useSystemDefault && !mime.isCurrentAppOSDefault()) { + return rv; + } + rv.shouldOpen = true; + // Log that we're doing this to help debug issues if people end up being + // surprised by this behaviour. + console.error("Found unusable PDF preferences. Fixing back to PDF.js"); + + mime.preferredAction = Ci.nsIHandlerInfo.handleInternally; + mime.alwaysAskBeforeHandling = false; + Svc.handlers.store(mime); + return true; + }, + + getConvertedType(aFromType, aChannel) { + const HTML = "text/html"; + let channelURI = aChannel?.URI; + // We can be invoked for application/octet-stream; check if we want the + // channel first: + if (aFromType != "application/pdf") { + // Check if the filename has a PDF extension. + let isPDF = false; + try { + isPDF = aChannel.contentDispositionFilename.endsWith(".pdf"); + } catch (ex) {} + if (!isPDF) { + isPDF = + channelURI?.QueryInterface(Ci.nsIURL).fileExtension.toLowerCase() == + "pdf"; + } + + let browsingContext = aChannel?.loadInfo.targetBrowsingContext; + let toplevelOctetStream = + aFromType == "application/octet-stream" && + browsingContext && + !browsingContext.parent; + if ( + !isPDF || + !toplevelOctetStream || + !getBoolPref(PREF_PREFIX + ".handleOctetStream", false) + ) { + throw new Components.Exception( + "Ignore PDF.js for this download.", + Cr.NS_ERROR_FAILURE + ); + } + // fall through, this appears to be a pdf. + } + + let { alwaysAskBeforeHandling, shouldOpen } = + this._validateAndMaybeUpdatePDFPrefs(); + + if (shouldOpen) { + return HTML; + } + // Hm, so normally, no pdfjs. However... if this is a file: channel there + // are some edge-cases. + if (channelURI?.schemeIs("file")) { + // If we're loaded with system principal, we were likely handed the PDF + // by the OS or directly from the URL bar. Assume we should load it: + let triggeringPrincipal = aChannel.loadInfo?.triggeringPrincipal; + if (triggeringPrincipal?.isSystemPrincipal) { + return HTML; + } + + // If we're loading from a file: link, load it in PDF.js unless the user + // has told us they always want to open/save PDFs. + // This is because handing off the choice to open in Firefox itself + // through the dialog doesn't work properly and making it work is + // non-trivial (see https://bugzilla.mozilla.org/show_bug.cgi?id=1680147#c3 ) + // - and anyway, opening the file is what we do for *all* + // other file types we handle internally (and users can then use other UI + // to save or open it with other apps from there). + if (triggeringPrincipal?.schemeIs("file") && alwaysAskBeforeHandling) { + return HTML; + } + } + + throw new Components.Exception("Can't use PDF.js", Cr.NS_ERROR_FAILURE); + }, + + // nsIStreamListener::onDataAvailable + onDataAvailable(aRequest, aInputStream, aOffset, aCount) { + if (!this.dataListener) { + return; + } + + var binaryStream = this.binaryStream; + binaryStream.setInputStream(aInputStream); + let chunk = new ArrayBuffer(aCount); + binaryStream.readArrayBuffer(aCount, chunk); + this.dataListener.append(new Uint8Array(chunk)); + }, + + // nsIRequestObserver::onStartRequest + onStartRequest(aRequest) { + // Setup the request so we can use it below. + var isHttpRequest = false; + try { + aRequest.QueryInterface(Ci.nsIHttpChannel); + isHttpRequest = true; + } catch (e) {} + + var rangeRequest = false; + var streamRequest = false; + if (isHttpRequest) { + var contentEncoding = "identity"; + try { + contentEncoding = aRequest.getResponseHeader("Content-Encoding"); + } catch (e) {} + + var acceptRanges; + try { + acceptRanges = aRequest.getResponseHeader("Accept-Ranges"); + } catch (e) {} + + var hash = aRequest.URI.ref; + var isPDFBugEnabled = getBoolPref(PREF_PREFIX + ".pdfBugEnabled", false); + rangeRequest = + contentEncoding === "identity" && + acceptRanges === "bytes" && + aRequest.contentLength >= 0 && + !getBoolPref(PREF_PREFIX + ".disableRange", false) && + (!isPDFBugEnabled || !hash.toLowerCase().includes("disablerange=true")); + streamRequest = + contentEncoding === "identity" && + aRequest.contentLength >= 0 && + !getBoolPref(PREF_PREFIX + ".disableStream", false) && + (!isPDFBugEnabled || + !hash.toLowerCase().includes("disablestream=true")); + } + + aRequest.QueryInterface(Ci.nsIChannel); + + aRequest.QueryInterface(Ci.nsIWritablePropertyBag); + + var contentDispositionFilename; + try { + contentDispositionFilename = aRequest.contentDispositionFilename; + } catch (e) {} + + if ( + contentDispositionFilename && + !/\.pdf$/i.test(contentDispositionFilename) + ) { + contentDispositionFilename += ".pdf"; + } + + // Change the content type so we don't get stuck in a loop. + aRequest.setProperty("contentType", aRequest.contentType); + aRequest.contentType = "text/html"; + if (isHttpRequest) { + // We trust PDF viewer, using no CSP + aRequest.setResponseHeader("Content-Security-Policy", "", false); + aRequest.setResponseHeader( + "Content-Security-Policy-Report-Only", + "", + false + ); + // The viewer does not need to handle HTTP Refresh header. + aRequest.setResponseHeader("Refresh", "", false); + } + + lazy.PdfJsTelemetry.onViewerIsUsed(); + + // The document will be loaded via the stream converter as html, + // but since we may have come here via a download or attachment + // that was opened directly, force the content disposition to be + // inline so that the html document will be loaded normally instead + // of going to the helper service. + aRequest.contentDisposition = Ci.nsIChannel.DISPOSITION_FORCE_INLINE; + + // Creating storage for PDF data + var contentLength = aRequest.contentLength; + this.dataListener = new PdfDataListener(contentLength); + this.binaryStream = Cc["@mozilla.org/binaryinputstream;1"].createInstance( + Ci.nsIBinaryInputStream + ); + + // Create a new channel that is viewer loaded as a resource. + var channel = lazy.NetUtil.newChannel({ + uri: PDF_VIEWER_WEB_PAGE, + loadUsingSystemPrincipal: true, + }); + + var listener = this.listener; + var dataListener = this.dataListener; + // Proxy all the request observer calls, when it gets to onStopRequest + // we can get the dom window. We also intentionally pass on the original + // request(aRequest) below so we don't overwrite the original channel and + // trigger an assertion. + var proxy = { + onStartRequest(request) { + listener.onStartRequest(aRequest); + }, + onDataAvailable(request, inputStream, offset, count) { + listener.onDataAvailable(aRequest, inputStream, offset, count); + }, + onStopRequest(request, statusCode) { + var domWindow = getDOMWindow(channel, resourcePrincipal); + if (!Components.isSuccessCode(statusCode) || !domWindow) { + // The request may have been aborted and the document may have been + // replaced with something that is not PDF.js, abort attaching. + listener.onStopRequest(aRequest, statusCode); + return; + } + var actions; + if (rangeRequest || streamRequest) { + actions = new RangedChromeActions( + domWindow, + contentDispositionFilename, + aRequest, + rangeRequest, + streamRequest, + dataListener + ); + } else { + actions = new StandardChromeActions( + domWindow, + contentDispositionFilename, + aRequest, + dataListener + ); + } + var requestListener = new RequestListener(actions); + domWindow.document.addEventListener( + PDFJS_EVENT_ID, + function (event) { + requestListener.receive(event); + }, + false, + true + ); + + let actor = getActor(domWindow); + actor?.init(actions.supportsIntegratedFind()); + + listener.onStopRequest(aRequest, statusCode); + }, + }; + + // Keep the URL the same so the browser sees it as the same. + channel.originalURI = aRequest.URI; + channel.loadGroup = aRequest.loadGroup; + channel.loadInfo.originAttributes = aRequest.loadInfo.originAttributes; + + // We can use the resource principal when data is fetched by the chrome, + // e.g. useful for NoScript. Make make sure we reuse the origin attributes + // from the request channel to keep isolation consistent. + var uri = lazy.NetUtil.newURI(PDF_VIEWER_WEB_PAGE); + var resourcePrincipal = + Services.scriptSecurityManager.createContentPrincipal( + uri, + aRequest.loadInfo.originAttributes + ); + // Remember the principal we would have had before we mess with it. + let originalPrincipal = + Services.scriptSecurityManager.getChannelResultPrincipal(aRequest); + aRequest.owner = resourcePrincipal; + aRequest.setProperty("noPDFJSPrincipal", originalPrincipal); + + channel.asyncOpen(proxy); + }, + + // nsIRequestObserver::onStopRequest + onStopRequest(aRequest, aStatusCode) { + if (!this.dataListener) { + // Do nothing + return; + } + + if (Components.isSuccessCode(aStatusCode)) { + this.dataListener.finish(); + } else { + this.dataListener.error(aStatusCode); + } + delete this.dataListener; + delete this.binaryStream; + }, +}; |