tor-browser

MozCachedOHTTPParent.sys.mjs (6598B)

---

/* 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/. */

const lazy = {};

ChromeUtils.defineESModuleGetters(lazy, {
 E10SUtils: "resource://gre/modules/E10SUtils.sys.mjs",
 NetUtil: "resource://gre/modules/NetUtil.sys.mjs",
});

// These match the serialization scheme used for header key/value pairs in
// nsHttpHeaderArray::FlattenOriginalHeader.
const RESPONSE_HEADER_KEY_VALUE_DELIMETER = ": ";
const RESPONSE_HEADER_DELIMETER = "\r\n";
const RESPONSE_HEADER_METADATA_ELEMENT = "original-response-headers";

/**
* Parent process JSActor for handling cache lookups for moz-cachged-ohttp
* protocol. This actor handles cache operations that require parent process
* privileges.
*/
export class MozCachedOHTTPParent extends JSProcessActorParent {
 receiveMessage(message) {
   if (
     this.manager.remoteType !== null &&
     this.manager.remoteType !== lazy.E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE
   ) {
     return Promise.reject(new Error("Process type mismatch"));
   }

   switch (message.name) {
     case "tryCache": {
       let uri = Services.io.newURI(message.data.uriString);
       return this.tryCache(uri);
     }
     case "writeCache": {
       let uri = Services.io.newURI(message.data.uriString);
       return this.writeCache(
         uri,
         message.data.cacheInputStream,
         message.data.cacheStreamUpdatePort
       );
     }
   }

   return Promise.reject(new Error(`Unknown message: ${message.name}`));
 }

 /**
  * Attempts to load the resource from the HTTP cache without making network
  * requests. On cache miss, provides an output stream for writing to cache.
  *
  * @param {nsIURI} resourceURI
  *   The URI of the resource to load from cache
  * @returns {Promise<object>}
  *   Promise that resolves to result object with success flag and data
  */
 async tryCache(resourceURI) {
   try {
     const cacheEntry = await this.#openCacheEntry(
       resourceURI,
       Ci.nsICacheStorage.OPEN_READONLY
     );

     if (!cacheEntry.dataSize) {
       throw new Error("Cache entry is empty.");
     }

     let headersStrings = cacheEntry
       .getMetaDataElement(RESPONSE_HEADER_METADATA_ELEMENT)
       .split(RESPONSE_HEADER_DELIMETER);
     let headersObj = {};
     for (let headersString of headersStrings) {
       let delimeterIndex = headersString.indexOf(
         RESPONSE_HEADER_KEY_VALUE_DELIMETER
       );
       let key = headersString.substring(0, delimeterIndex);
       let value = headersString.substring(
         delimeterIndex + RESPONSE_HEADER_KEY_VALUE_DELIMETER.length
       );
       headersObj[key] = value;
     }

     // Cache hit - return input stream for reading
     const inputStream = cacheEntry.openInputStream(0);

     return {
       success: true,
       inputStream,
       headersObj,
     };
   } catch (e) {
     // Cache miss or error - proceed without caching
     return { success: false };
   }
 }

 /**
  * Writes resource data to the HTTP cache. Opens a cache entry for the
  * specified URI and copies data from the input stream to the cache, handling
  * cache control messages for expiration and entry management.
  *
  * @param {nsIURI} resourceURI
  *   The URI of the resource to cache
  * @param {nsIInputStream} cacheInputStream
  *   Input stream containing the resource data to cache
  * @param {MessageChannelPort} cacheStreamUpdatePort
  *   MessagePort for receiving cache control messages:
  *   - "DoomCacheEntry": Remove cache entry (on error/no-cache)
  *   - "WriteCacheExpiry": Set cache expiration time
  * @returns {Promise<undefined>}
  *   Promise that resolves when caching is complete
  */
 async writeCache(resourceURI, cacheInputStream, cacheStreamUpdatePort) {
   let cacheEntry;
   let outputStream;

   try {
     cacheEntry = await this.#openCacheEntry(
       resourceURI,
       Ci.nsICacheStorage.OPEN_NORMALLY
     );
     outputStream = cacheEntry.openOutputStream(0, -1);
   } catch (e) {
     return;
   }

   cacheStreamUpdatePort.onmessage = msg => {
     switch (msg.data.name) {
       case "DoomCacheEntry": {
         cacheEntry.asyncDoom(null);
         break;
       }
       case "WriteOriginalResponseHeaders": {
         let headers = new Headers(msg.data.headersObj);
         let headersStrings = [];
         for (let [key, value] of headers.entries()) {
           headersStrings.push(
             `${key}${RESPONSE_HEADER_KEY_VALUE_DELIMETER}${value}`
           );
         }
         cacheEntry.setMetaDataElement(
           RESPONSE_HEADER_METADATA_ELEMENT,
           headersStrings.join(RESPONSE_HEADER_DELIMETER)
         );
         break;
       }
       case "WriteCacheExpiry": {
         cacheEntry.setExpirationTime(msg.data.expiry);
         break;
       }
     }
   };
   try {
     await new Promise(resolve => {
       lazy.NetUtil.asyncCopy(cacheInputStream, outputStream, writeResult => {
         if (!Components.isSuccessCode(writeResult)) {
           console.error(
             "Failed to cache moz-cached-ohttp resource with result: ",
             writeResult
           );
         }

         resolve();
       });
     });
   } finally {
     cacheStreamUpdatePort.onmessage = null;
   }
 }

 /**
  * Opens a cache entry for the specified URI.
  *
  * @param {nsIURI} uri
  *   The URI to open cache entry for.
  * @param {number} openFlags
  *   Cache storage open flags.
  * @returns {Promise<nsICacheEntry|null>}
  *   Promise that resolves to cache entry or null if not available.
  */
 async #openCacheEntry(uri, openFlags) {
   const lci = Services.loadContextInfo.anonymous;
   const storage = Services.cache2.diskCacheStorage(lci);

   // For read-only access, check existence first
   if (
     openFlags === Ci.nsICacheStorage.OPEN_READONLY &&
     !storage.exists(uri, "")
   ) {
     throw new Error("Cache entry does not exist.");
   }

   return new Promise((resolve, reject) => {
     storage.asyncOpenURI(uri, "", openFlags, {
       onCacheEntryCheck: () => Ci.nsICacheEntryOpenCallback.ENTRY_WANTED,
       onCacheEntryAvailable: (entry, _isNew, status) => {
         if (Components.isSuccessCode(status)) {
           resolve(entry);
         } else {
           reject(new Error(`Cache entry operation failed: ${status}`));
         }
       },
     });
   });
 }
}