diff options
Diffstat (limited to 'netwerk/base/nsStandardURL.h')
| -rw-r--r-- | netwerk/base/nsStandardURL.h | 550 |
1 files changed, 550 insertions, 0 deletions
diff --git a/netwerk/base/nsStandardURL.h b/netwerk/base/nsStandardURL.h new file mode 100644 index 0000000000..6efb58648d --- /dev/null +++ b/netwerk/base/nsStandardURL.h @@ -0,0 +1,550 @@ +/* -*- Mode: C++; tab-width: 4; 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/. */ + +#ifndef nsStandardURL_h__ +#define nsStandardURL_h__ + +#include "nsString.h" +#include "nsISerializable.h" +#include "nsIFileURL.h" +#include "nsIStandardURL.h" +#include "mozilla/Encoding.h" +#include "nsCOMPtr.h" +#include "nsURLHelper.h" +#include "nsISizeOf.h" +#include "mozilla/Attributes.h" +#include "mozilla/LinkedList.h" +#include "mozilla/MemoryReporting.h" +#include "nsISensitiveInfoHiddenURI.h" +#include "nsIURIMutator.h" + +#ifdef NS_BUILD_REFCNT_LOGGING +# define DEBUG_DUMP_URLS_AT_SHUTDOWN +#endif + +class nsIBinaryInputStream; +class nsIBinaryOutputStream; +class nsIIDNService; +class nsIPrefBranch; +class nsIFile; +class nsIURLParser; + +namespace mozilla { +class Encoding; +namespace net { + +//----------------------------------------------------------------------------- +// standard URL implementation +//----------------------------------------------------------------------------- + +class nsStandardURL : public nsIFileURL, + public nsIStandardURL, + public nsISerializable, + public nsISizeOf, + public nsISensitiveInfoHiddenURI +#ifdef DEBUG_DUMP_URLS_AT_SHUTDOWN + , + public LinkedListElement<nsStandardURL> +#endif +{ + protected: + virtual ~nsStandardURL(); + explicit nsStandardURL(bool aSupportsFileURL = false, bool aTrackURL = true); + + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIURI + NS_DECL_NSIURL + NS_DECL_NSIFILEURL + NS_DECL_NSISTANDARDURL + NS_DECL_NSISERIALIZABLE + NS_DECL_NSISENSITIVEINFOHIDDENURI + + // nsISizeOf + virtual size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const override; + virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const override; + + static void InitGlobalObjects(); + static void ShutdownGlobalObjects(); + + public: /* internal -- HPUX compiler can't handle this being private */ + // + // location and length of an url segment relative to mSpec + // + struct URLSegment { + uint32_t mPos; + int32_t mLen; + + URLSegment() : mPos(0), mLen(-1) {} + URLSegment(uint32_t pos, int32_t len) : mPos(pos), mLen(len) {} + URLSegment(const URLSegment& aCopy) = default; + void Reset() { + mPos = 0; + mLen = -1; + } + // Merge another segment following this one to it if they're contiguous + // Assumes we have something like "foo;bar" where this object is 'foo' and + // right is 'bar'. + void Merge(const nsCString& spec, const char separator, + const URLSegment& right) { + if (mLen >= 0 && *(spec.get() + mPos + mLen) == separator && + mPos + mLen + 1 == right.mPos) { + mLen += 1 + right.mLen; + } + } + }; + + // + // URL segment encoder : performs charset conversion and URL escaping. + // + class nsSegmentEncoder { + public: + explicit nsSegmentEncoder(const Encoding* encoding = nullptr); + + // Encode the given segment if necessary, and return the length of + // the encoded segment. The encoded segment is appended to |aOut| + // if and only if encoding is required. + int32_t EncodeSegmentCount(const char* str, const URLSegment& aSeg, + int16_t mask, nsCString& aOut, bool& appended, + uint32_t extraLen = 0); + + // Encode the given string if necessary, and return a reference to + // the encoded string. Returns a reference to |result| if encoding + // is required. Otherwise, a reference to |str| is returned. + const nsACString& EncodeSegment(const nsACString& str, int16_t mask, + nsCString& result); + + private: + const Encoding* mEncoding; + }; + friend class nsSegmentEncoder; + + static nsresult NormalizeIPv4(const nsACString& host, nsCString& result); + + protected: + // enum used in a few places to specify how .ref attribute should be handled + enum RefHandlingEnum { eIgnoreRef, eHonorRef, eReplaceRef }; + + // Helper to share code between Equals and EqualsExceptRef + // NOTE: *not* virtual, because no one needs to override this so far... + nsresult EqualsInternal(nsIURI* unknownOther, RefHandlingEnum refHandlingMode, + bool* result); + + virtual nsStandardURL* StartClone(); + + // Helper to share code between Clone methods. + nsresult CloneInternal(RefHandlingEnum aRefHandlingMode, + const nsACString& aNewRef, nsIURI** aClone); + // Helper method that copies member variables from the source StandardURL + // if copyCached = true, it will also copy mFile and mDisplayHost + nsresult CopyMembers(nsStandardURL* source, RefHandlingEnum mode, + const nsACString& newRef, bool copyCached = false); + + // Helper for subclass implementation of GetFile(). Subclasses that map + // URIs to files in a special way should implement this method. It should + // ensure that our mFile is initialized, if it's possible. + // returns NS_ERROR_NO_INTERFACE if the url does not map to a file + virtual nsresult EnsureFile(); + + virtual nsresult Clone(nsIURI** aURI); + virtual nsresult SetSpecInternal(const nsACString& input); + virtual nsresult SetScheme(const nsACString& input); + virtual nsresult SetUserPass(const nsACString& input); + virtual nsresult SetUsername(const nsACString& input); + virtual nsresult SetPassword(const nsACString& input); + virtual nsresult SetHostPort(const nsACString& aValue); + virtual nsresult SetHost(const nsACString& input); + virtual nsresult SetPort(int32_t port); + virtual nsresult SetPathQueryRef(const nsACString& input); + virtual nsresult SetRef(const nsACString& input); + virtual nsresult SetFilePath(const nsACString& input); + virtual nsresult SetQuery(const nsACString& input); + virtual nsresult SetQueryWithEncoding(const nsACString& input, + const Encoding* encoding); + bool Deserialize(const mozilla::ipc::URIParams&); + nsresult ReadPrivate(nsIObjectInputStream* stream); + + private: + nsresult Init(uint32_t urlType, int32_t defaultPort, const nsACString& spec, + const char* charset, nsIURI* baseURI); + nsresult SetDefaultPort(int32_t aNewDefaultPort); + nsresult SetFile(nsIFile* file); + + nsresult SetFileNameInternal(const nsACString& input); + nsresult SetFileBaseNameInternal(const nsACString& input); + nsresult SetFileExtensionInternal(const nsACString& input); + + int32_t Port() { return mPort == -1 ? mDefaultPort : mPort; } + + void ReplacePortInSpec(int32_t aNewPort); + void Clear(); + void InvalidateCache(bool invalidateCachedFile = true); + + bool ValidIPv6orHostname(const char* host, uint32_t length); + static bool IsValidOfBase(unsigned char c, const uint32_t base); + nsresult NormalizeIDN(const nsACString& host, nsCString& result); + nsresult CheckIfHostIsAscii(); + void CoalescePath(netCoalesceFlags coalesceFlag, char* path); + + uint32_t AppendSegmentToBuf(char*, uint32_t, const char*, + const URLSegment& input, URLSegment& output, + const nsCString* esc = nullptr, + bool useEsc = false, int32_t* diff = nullptr); + uint32_t AppendToBuf(char*, uint32_t, const char*, uint32_t); + + nsresult BuildNormalizedSpec(const char* spec, const Encoding* encoding); + nsresult SetSpecWithEncoding(const nsACString& input, + const Encoding* encoding); + + bool SegmentIs(const URLSegment& seg, const char* val, + bool ignoreCase = false); + bool SegmentIs(const char* spec, const URLSegment& seg, const char* val, + bool ignoreCase = false); + bool SegmentIs(const URLSegment& seg1, const char* val, + const URLSegment& seg2, bool ignoreCase = false); + + int32_t ReplaceSegment(uint32_t pos, uint32_t len, const char* val, + uint32_t valLen); + int32_t ReplaceSegment(uint32_t pos, uint32_t len, const nsACString& val); + + nsresult ParseURL(const char* spec, int32_t specLen); + nsresult ParsePath(const char* spec, uint32_t pathPos, int32_t pathLen = -1); + + char* AppendToSubstring(uint32_t pos, int32_t len, const char* tail); + + // dependent substring helpers + const nsDependentCSubstring Segment(uint32_t pos, int32_t len); // see below + const nsDependentCSubstring Segment(const URLSegment& s) { + return Segment(s.mPos, s.mLen); + } + + // dependent substring getters + const nsDependentCSubstring Prepath(); // see below + const nsDependentCSubstring Scheme() { return Segment(mScheme); } + const nsDependentCSubstring Userpass(bool includeDelim = false); // see below + const nsDependentCSubstring Username() { return Segment(mUsername); } + const nsDependentCSubstring Password() { return Segment(mPassword); } + const nsDependentCSubstring Hostport(); // see below + const nsDependentCSubstring Host(); // see below + const nsDependentCSubstring Path() { return Segment(mPath); } + const nsDependentCSubstring Filepath() { return Segment(mFilepath); } + const nsDependentCSubstring Directory() { return Segment(mDirectory); } + const nsDependentCSubstring Filename(); // see below + const nsDependentCSubstring Basename() { return Segment(mBasename); } + const nsDependentCSubstring Extension() { return Segment(mExtension); } + const nsDependentCSubstring Query() { return Segment(mQuery); } + const nsDependentCSubstring Ref() { return Segment(mRef); } + + // shift the URLSegments to the right by diff + void ShiftFromAuthority(int32_t diff); + void ShiftFromUsername(int32_t diff); + void ShiftFromPassword(int32_t diff); + void ShiftFromHost(int32_t diff); + void ShiftFromPath(int32_t diff); + void ShiftFromFilepath(int32_t diff); + void ShiftFromDirectory(int32_t diff); + void ShiftFromBasename(int32_t diff); + void ShiftFromExtension(int32_t diff); + void ShiftFromQuery(int32_t diff); + void ShiftFromRef(int32_t diff); + + // fastload helper functions + nsresult ReadSegment(nsIBinaryInputStream*, URLSegment&); + nsresult WriteSegment(nsIBinaryOutputStream*, const URLSegment&); + + void FindHostLimit(nsACString::const_iterator& aStart, + nsACString::const_iterator& aEnd); + + // Asserts that the URLSegment has sane values + static void SanityCheck(const URLSegment&, const nsCString&); + + // mSpec contains the normalized version of the URL spec (UTF-8 encoded). + nsCString mSpec; + int32_t mDefaultPort; + int32_t mPort; + + // url parts (relative to mSpec) + URLSegment mScheme; + URLSegment mAuthority; + URLSegment mUsername; + URLSegment mPassword; + URLSegment mHost; + URLSegment mPath; + URLSegment mFilepath; + URLSegment mDirectory; + URLSegment mBasename; + URLSegment mExtension; + URLSegment mQuery; + URLSegment mRef; + + nsCOMPtr<nsIURLParser> mParser; + + // mFile is protected so subclasses can access it directly + protected: + nsCOMPtr<nsIFile> mFile; // cached result for nsIFileURL::GetFile + + private: + // cached result for nsIURI::GetDisplayHost + nsCString mDisplayHost; + + enum { eEncoding_Unknown, eEncoding_ASCII, eEncoding_UTF8 }; + + uint32_t mURLType : 2; // nsIStandardURL::URLTYPE_xxx + uint32_t mSupportsFileURL : 1; // QI to nsIFileURL? + uint32_t mCheckedIfHostA : 1; // If set to true, it means either that + // mDisplayHost has a been initialized, or + // that the hostname is not punycode + + // global objects. + static StaticRefPtr<nsIIDNService> gIDN; + static const char gHostLimitDigits[]; + static bool gInitialized; + + public: +#ifdef DEBUG_DUMP_URLS_AT_SHUTDOWN + void PrintSpec() const { printf(" %s\n", mSpec.get()); } +#endif + + public: + // We make this implementation a template so that we can avoid writing + // the same code for SubstitutingURL (which extends nsStandardURL) + template <class T> + class TemplatedMutator : public nsIURIMutator, + public BaseURIMutator<T>, + public nsIStandardURLMutator, + public nsIURLMutator, + public nsIFileURLMutator, + public nsISerializable { + NS_FORWARD_SAFE_NSIURISETTERS_RET(BaseURIMutator<T>::mURI) + + [[nodiscard]] NS_IMETHOD Deserialize( + const mozilla::ipc::URIParams& aParams) override { + return BaseURIMutator<T>::InitFromIPCParams(aParams); + } + + NS_IMETHOD + Write(nsIObjectOutputStream* aOutputStream) override { + MOZ_ASSERT_UNREACHABLE("Use nsIURIMutator.read() instead"); + return NS_ERROR_NOT_IMPLEMENTED; + } + + [[nodiscard]] NS_IMETHOD Read(nsIObjectInputStream* aStream) override { + return BaseURIMutator<T>::InitFromInputStream(aStream); + } + + [[nodiscard]] NS_IMETHOD Finalize(nsIURI** aURI) override { + BaseURIMutator<T>::mURI.forget(aURI); + return NS_OK; + } + + [[nodiscard]] NS_IMETHOD SetSpec(const nsACString& aSpec, + nsIURIMutator** aMutator) override { + if (aMutator) { + nsCOMPtr<nsIURIMutator> mutator = this; + mutator.forget(aMutator); + } + return BaseURIMutator<T>::InitFromSpec(aSpec); + } + + [[nodiscard]] NS_IMETHOD Init(uint32_t aURLType, int32_t aDefaultPort, + const nsACString& aSpec, const char* aCharset, + nsIURI* aBaseURI, + nsIURIMutator** aMutator) override { + if (aMutator) { + nsCOMPtr<nsIURIMutator> mutator = this; + mutator.forget(aMutator); + } + RefPtr<T> uri; + if (BaseURIMutator<T>::mURI) { + // We don't need a new URI object if we already have one + BaseURIMutator<T>::mURI.swap(uri); + } else { + uri = Create(); + } + nsresult rv = + uri->Init(aURLType, aDefaultPort, aSpec, aCharset, aBaseURI); + if (NS_FAILED(rv)) { + return rv; + } + BaseURIMutator<T>::mURI = std::move(uri); + return NS_OK; + } + + [[nodiscard]] NS_IMETHODIMP SetDefaultPort( + int32_t aNewDefaultPort, nsIURIMutator** aMutator) override { + if (!BaseURIMutator<T>::mURI) { + return NS_ERROR_NULL_POINTER; + } + if (aMutator) { + nsCOMPtr<nsIURIMutator> mutator = this; + mutator.forget(aMutator); + } + return BaseURIMutator<T>::mURI->SetDefaultPort(aNewDefaultPort); + } + + [[nodiscard]] NS_IMETHOD SetFileName(const nsACString& aFileName, + nsIURIMutator** aMutator) override { + if (!BaseURIMutator<T>::mURI) { + return NS_ERROR_NULL_POINTER; + } + if (aMutator) { + nsCOMPtr<nsIURIMutator> mutator = this; + mutator.forget(aMutator); + } + return BaseURIMutator<T>::mURI->SetFileNameInternal(aFileName); + } + + [[nodiscard]] NS_IMETHOD SetFileBaseName( + const nsACString& aFileBaseName, nsIURIMutator** aMutator) override { + if (!BaseURIMutator<T>::mURI) { + return NS_ERROR_NULL_POINTER; + } + if (aMutator) { + nsCOMPtr<nsIURIMutator> mutator = this; + mutator.forget(aMutator); + } + return BaseURIMutator<T>::mURI->SetFileBaseNameInternal(aFileBaseName); + } + + [[nodiscard]] NS_IMETHOD SetFileExtension( + const nsACString& aFileExtension, nsIURIMutator** aMutator) override { + if (!BaseURIMutator<T>::mURI) { + return NS_ERROR_NULL_POINTER; + } + if (aMutator) { + nsCOMPtr<nsIURIMutator> mutator = this; + mutator.forget(aMutator); + } + return BaseURIMutator<T>::mURI->SetFileExtensionInternal(aFileExtension); + } + + T* Create() override { return new T(mMarkedFileURL); } + + [[nodiscard]] NS_IMETHOD MarkFileURL() override { + mMarkedFileURL = true; + return NS_OK; + } + + [[nodiscard]] NS_IMETHOD SetFile(nsIFile* aFile) override { + RefPtr<T> uri; + if (BaseURIMutator<T>::mURI) { + // We don't need a new URI object if we already have one + BaseURIMutator<T>::mURI.swap(uri); + } else { + uri = new T(/* aSupportsFileURL = */ true); + } + + nsresult rv = uri->SetFile(aFile); + if (NS_FAILED(rv)) { + return rv; + } + BaseURIMutator<T>::mURI.swap(uri); + return NS_OK; + } + + explicit TemplatedMutator() : mMarkedFileURL(false) {} + + private: + virtual ~TemplatedMutator() = default; + + bool mMarkedFileURL = false; + + friend T; + }; + + class Mutator final : public TemplatedMutator<nsStandardURL> { + NS_DECL_ISUPPORTS + public: + explicit Mutator() = default; + + private: + virtual ~Mutator() = default; + }; + + friend BaseURIMutator<nsStandardURL>; +}; + +#define NS_THIS_STANDARDURL_IMPL_CID \ + { /* b8e3e97b-1ccd-4b45-af5a-79596770f5d7 */ \ + 0xb8e3e97b, 0x1ccd, 0x4b45, { \ + 0xaf, 0x5a, 0x79, 0x59, 0x67, 0x70, 0xf5, 0xd7 \ + } \ + } + +//----------------------------------------------------------------------------- +// Dependent substring getters +//----------------------------------------------------------------------------- + +inline const nsDependentCSubstring nsStandardURL::Segment(uint32_t pos, + int32_t len) { + if (len < 0) { + pos = 0; + len = 0; + } + return Substring(mSpec, pos, uint32_t(len)); +} + +inline const nsDependentCSubstring nsStandardURL::Prepath() { + uint32_t len = 0; + if (mAuthority.mLen >= 0) len = mAuthority.mPos + mAuthority.mLen; + return Substring(mSpec, 0, len); +} + +inline const nsDependentCSubstring nsStandardURL::Userpass(bool includeDelim) { + uint32_t pos = 0, len = 0; + if (mUsername.mLen > 0 || mPassword.mLen > 0) { + if (mUsername.mLen > 0) { + pos = mUsername.mPos; + len = mUsername.mLen; + if (mPassword.mLen >= 0) { + len += (mPassword.mLen + 1); + } + } else { + pos = mPassword.mPos - 1; + len = mPassword.mLen + 1; + } + + if (includeDelim) len++; + } + return Substring(mSpec, pos, len); +} + +inline const nsDependentCSubstring nsStandardURL::Hostport() { + uint32_t pos = 0, len = 0; + if (mAuthority.mLen > 0) { + pos = mHost.mPos; + len = mAuthority.mPos + mAuthority.mLen - pos; + } + return Substring(mSpec, pos, len); +} + +inline const nsDependentCSubstring nsStandardURL::Host() { + uint32_t pos = 0, len = 0; + if (mHost.mLen > 0) { + pos = mHost.mPos; + len = mHost.mLen; + if (mSpec.CharAt(pos) == '[' && mSpec.CharAt(pos + len - 1) == ']') { + pos++; + len -= 2; + } + } + return Substring(mSpec, pos, len); +} + +inline const nsDependentCSubstring nsStandardURL::Filename() { + uint32_t pos = 0, len = 0; + // if there is no basename, then there can be no extension + if (mBasename.mLen > 0) { + pos = mBasename.mPos; + len = mBasename.mLen; + if (mExtension.mLen >= 0) len += (mExtension.mLen + 1); + } + return Substring(mSpec, pos, len); +} + +} // namespace net +} // namespace mozilla + +#endif // nsStandardURL_h__ |