From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- startupcache/StartupCacheUtils.cpp | 225 +++++++++++++++++++++++++++++++++++++ 1 file changed, 225 insertions(+) create mode 100644 startupcache/StartupCacheUtils.cpp (limited to 'startupcache/StartupCacheUtils.cpp') diff --git a/startupcache/StartupCacheUtils.cpp b/startupcache/StartupCacheUtils.cpp new file mode 100644 index 0000000000..c8dcdd7f11 --- /dev/null +++ b/startupcache/StartupCacheUtils.cpp @@ -0,0 +1,225 @@ +/* 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 "nsCOMPtr.h" +#include "nsIInputStream.h" +#include "nsNetUtil.h" +#include "nsIFileURL.h" +#include "nsIJARURI.h" +#include "nsIResProtocolHandler.h" +#include "nsIChromeRegistry.h" +#include "nsStringStream.h" +#include "StartupCacheUtils.h" +#include "mozilla/scache/StartupCache.h" +#include "mozilla/Omnijar.h" + +namespace mozilla { +namespace scache { + +nsresult NewObjectInputStreamFromBuffer(const char* buffer, uint32_t len, + nsIObjectInputStream** stream) { + nsCOMPtr stringStream; + nsresult rv = NS_NewByteInputStream(getter_AddRefs(stringStream), + Span(buffer, len), NS_ASSIGNMENT_DEPEND); + MOZ_ALWAYS_SUCCEEDS(rv); + + nsCOMPtr objectInput = + NS_NewObjectInputStream(stringStream); + + objectInput.forget(stream); + return NS_OK; +} + +nsresult NewObjectOutputWrappedStorageStream( + nsIObjectOutputStream** wrapperStream, nsIStorageStream** stream, + bool wantDebugStream) { + nsCOMPtr storageStream; + + nsresult rv = + NS_NewStorageStream(256, UINT32_MAX, getter_AddRefs(storageStream)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr outputStream = do_QueryInterface(storageStream); + + nsCOMPtr objectOutput = + NS_NewObjectOutputStream(outputStream); + +#ifdef DEBUG + if (wantDebugStream) { + // Wrap in debug stream to detect unsupported writes of + // multiply-referenced non-singleton objects + StartupCache* sc = StartupCache::GetSingleton(); + NS_ENSURE_TRUE(sc, NS_ERROR_UNEXPECTED); + nsCOMPtr debugStream; + sc->GetDebugObjectOutputStream(objectOutput, getter_AddRefs(debugStream)); + debugStream.forget(wrapperStream); + } else { + objectOutput.forget(wrapperStream); + } +#else + objectOutput.forget(wrapperStream); +#endif + + storageStream.forget(stream); + return NS_OK; +} + +nsresult NewBufferFromStorageStream(nsIStorageStream* storageStream, + UniqueFreePtr* buffer, + uint32_t* len) { + nsresult rv; + nsCOMPtr inputStream; + rv = storageStream->NewInputStream(0, getter_AddRefs(inputStream)); + NS_ENSURE_SUCCESS(rv, rv); + + uint64_t avail64; + rv = inputStream->Available(&avail64); + NS_ENSURE_SUCCESS(rv, rv); + NS_ENSURE_TRUE(avail64 <= UINT32_MAX, NS_ERROR_FILE_TOO_BIG); + + uint32_t avail = (uint32_t)avail64; + auto temp = UniqueFreePtr( + reinterpret_cast(malloc(sizeof(char) * avail))); + uint32_t read; + rv = inputStream->Read(temp.get(), avail, &read); + if (NS_SUCCEEDED(rv) && avail != read) rv = NS_ERROR_UNEXPECTED; + + if (NS_FAILED(rv)) { + return rv; + } + + *len = avail; + *buffer = std::move(temp); + return NS_OK; +} + +static const char baseName[2][5] = {"gre/", "app/"}; + +static inline bool canonicalizeBase(nsAutoCString& spec, nsACString& out) { + nsAutoCString greBase, appBase; + nsresult rv = mozilla::Omnijar::GetURIString(mozilla::Omnijar::GRE, greBase); + if (NS_FAILED(rv) || !greBase.Length()) return false; + + rv = mozilla::Omnijar::GetURIString(mozilla::Omnijar::APP, appBase); + if (NS_FAILED(rv)) return false; + + bool underGre = StringBeginsWith(spec, greBase); + bool underApp = appBase.Length() && StringBeginsWith(spec, appBase); + + if (!underGre && !underApp) return false; + + /** + * At this point, if both underGre and underApp are true, it can be one + * of the two following cases: + * - the GRE directory points to a subdirectory of the APP directory, + * meaning spec points under GRE. + * - the APP directory points to a subdirectory of the GRE directory, + * meaning spec points under APP. + * Checking the GRE and APP path length is enough to know in which case + * we are. + */ + if (underGre && underApp && greBase.Length() < appBase.Length()) + underGre = false; + + out.AppendLiteral("/resource/"); + out.Append( + baseName[underGre ? mozilla::Omnijar::GRE : mozilla::Omnijar::APP]); + out.Append(Substring(spec, underGre ? greBase.Length() : appBase.Length())); + return true; +} + +/** + * ResolveURI transforms a chrome: or resource: URI into the URI for its + * underlying resource, or returns any other URI unchanged. + */ +nsresult ResolveURI(nsIURI* in, nsIURI** out) { + nsresult rv; + + // Resolve resource:// URIs. At the end of this if/else block, we + // have both spec and uri variables identifying the same URI. + if (in->SchemeIs("resource")) { + nsCOMPtr ioService = do_GetIOService(&rv); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr ph; + rv = ioService->GetProtocolHandler("resource", getter_AddRefs(ph)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr irph(do_QueryInterface(ph, &rv)); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoCString spec; + rv = irph->ResolveURI(in, spec); + NS_ENSURE_SUCCESS(rv, rv); + + return ioService->NewURI(spec, nullptr, nullptr, out); + } + if (in->SchemeIs("chrome")) { + nsCOMPtr chromeReg = + mozilla::services::GetChromeRegistry(); + if (!chromeReg) return NS_ERROR_UNEXPECTED; + + return chromeReg->ConvertChromeURL(in, out); + } + + *out = do_AddRef(in).take(); + return NS_OK; +} + +static nsresult PathifyURIImpl(nsIURI* in, nsACString& out) { + nsCOMPtr uri; + nsresult rv = ResolveURI(in, getter_AddRefs(uri)); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoCString spec; + rv = uri->GetSpec(spec); + NS_ENSURE_SUCCESS(rv, rv); + + if (!canonicalizeBase(spec, out)) { + if (uri->SchemeIs("file")) { + nsCOMPtr baseFileURL; + baseFileURL = do_QueryInterface(uri, &rv); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoCString path; + rv = baseFileURL->GetPathQueryRef(path); + NS_ENSURE_SUCCESS(rv, rv); + + out.Append(path); + } else if (uri->SchemeIs("jar")) { + nsCOMPtr jarURI = do_QueryInterface(uri, &rv); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr jarFileURI; + rv = jarURI->GetJARFile(getter_AddRefs(jarFileURI)); + NS_ENSURE_SUCCESS(rv, rv); + + rv = PathifyURIImpl(jarFileURI, out); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoCString path; + rv = jarURI->GetJAREntry(path); + NS_ENSURE_SUCCESS(rv, rv); + out.Append('/'); + out.Append(path); + } else { // Very unlikely + rv = uri->GetSpec(spec); + NS_ENSURE_SUCCESS(rv, rv); + + out.Append('/'); + out.Append(spec); + } + } + return NS_OK; +} + +nsresult PathifyURI(const char* loaderType, size_t loaderTypeLength, nsIURI* in, + nsACString& out) { + out.AssignASCII(loaderType, loaderTypeLength); + + return PathifyURIImpl(in, out); +} + +} // namespace scache +} // namespace mozilla -- cgit v1.2.3