Source code

Revision control

Other Tools

/* -*- 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 "nsIClassInfo.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 nsIClassInfo,
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_NSICLASSINFO
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 |buf|
// if and only if encoding is required.
int32_t EncodeSegmentCount(const char* str, const URLSegment& segment,
int16_t mask, nsCString& buf, bool& appended,
uint32_t extraLen = 0);
// Encode the given string if necessary, and return a reference to
// the encoded string. Returns a reference to |buf| if encoding
// is required. Otherwise, a reference to |str| is returned.
const nsACString& EncodeSegment(const nsACString& str, int16_t mask,
nsCString& buf);
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& newRef, 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 aLen);
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& s1, const char* val,
bool ignoreCase = false);
bool SegmentIs(const char* spec, const URLSegment& s1, const char* val,
bool ignoreCase = false);
bool SegmentIs(const URLSegment& s1, const char* val, const URLSegment& s2,
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);
// 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;
static bool gPunycodeHost;
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__