void
Location::SetSearch(const nsAString& aSearch,
nsIPrincipal& aSubjectPrincipal,
ErrorResult& aRv)
{
if (!CallerSubsumes(&aSubjectPrincipal)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
nsCOMPtr<nsIURI> uri;
aRv = GetURI(getter_AddRefs(uri));
nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
if (NS_WARN_IF(aRv.Failed()) || !url) {
return;
}
if (nsIDocument* doc = GetEntryDocument()) {
aRv = NS_MutateURI(uri)
.SetQueryWithEncoding(NS_ConvertUTF16toUTF8(aSearch),
doc->GetDocumentCharacterSet())
.Finalize(uri);
} else {
aRv = NS_MutateURI(uri)
.SetQuery(NS_ConvertUTF16toUTF8(aSearch))
.Finalize(uri);
}
if (NS_WARN_IF(aRv.Failed())) {
return;
}
aRv = SetURI(uri);
}
void URL::SetHost(const nsAString& aHost) {
MOZ_ASSERT(mURI);
Unused << NS_MutateURI(mURI)
.SetHostPort(NS_ConvertUTF16toUTF8(aHost))
.Finalize(mURI);
}
void
Location::SetHash(const nsAString& aHash,
nsIPrincipal& aSubjectPrincipal,
ErrorResult& aRv)
{
if (!CallerSubsumes(&aSubjectPrincipal)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
NS_ConvertUTF16toUTF8 hash(aHash);
if (hash.IsEmpty() || hash.First() != char16_t('#')) {
hash.Insert(char16_t('#'), 0);
}
nsCOMPtr<nsIURI> uri;
aRv = GetURI(getter_AddRefs(uri));
if (NS_WARN_IF(aRv.Failed()) || !uri) {
return;
}
aRv = NS_MutateURI(uri)
.SetRef(hash)
.Finalize(uri);
if (NS_WARN_IF(aRv.Failed()) || !uri) {
return;
}
aRv = SetURI(uri);
}
void URL::SetUsername(const nsAString& aUsername) {
MOZ_ASSERT(mURI);
Unused << NS_MutateURI(mURI)
.SetUsername(NS_ConvertUTF16toUTF8(aUsername))
.Finalize(mURI);
}
void URLMainThread::SetProtocol(const nsAString& aProtocol, ErrorResult& aRv) {
nsAString::const_iterator start, end;
aProtocol.BeginReading(start);
aProtocol.EndReading(end);
nsAString::const_iterator iter(start);
FindCharInReadable(':', iter, end);
// Changing the protocol of a URL, changes the "nature" of the URI
// implementation. In order to do this properly, we have to serialize the
// existing URL and reparse it in a new object.
nsCOMPtr<nsIURI> clone;
nsresult rv = NS_MutateURI(GetURI())
.SetScheme(NS_ConvertUTF16toUTF8(Substring(start, iter)))
.Finalize(clone);
if (NS_WARN_IF(NS_FAILED(rv))) {
return;
}
nsAutoCString href;
rv = clone->GetSpec(href);
if (NS_WARN_IF(NS_FAILED(rv))) {
return;
}
nsCOMPtr<nsIURI> uri;
rv = NS_NewURI(getter_AddRefs(uri), href);
if (NS_WARN_IF(NS_FAILED(rv))) {
return;
}
SetURI(uri.forget());
}
void URL::SetPassword(const nsAString& aPassword) {
MOZ_ASSERT(mURI);
Unused << NS_MutateURI(mURI)
.SetPassword(NS_ConvertUTF16toUTF8(aPassword))
.Finalize(mURI);
}
NS_IMETHODIMP
nsChromeProtocolHandler::NewURI(const nsACString &aSpec, const char *aCharset,
nsIURI *aBaseURI, nsIURI **result) {
// Chrome: URLs (currently) have no additional structure beyond that provided
// by standard URLs, so there is no "outer" given to CreateInstance
nsresult rv;
nsCOMPtr<nsIURI> surl;
nsCOMPtr<nsIURI> base(aBaseURI);
rv = NS_MutateURI(new mozilla::net::nsStandardURL::Mutator())
.Apply(NS_MutatorMethod(&nsIStandardURLMutator::Init,
nsIStandardURL::URLTYPE_STANDARD, -1,
nsCString(aSpec), aCharset, base, nullptr))
.Finalize(surl);
if (NS_FAILED(rv)) {
return rv;
}
// Canonify the "chrome:" URL; e.g., so that we collapse
// "chrome://navigator/content/" and "chrome://navigator/content"
// and "chrome://navigator/content/navigator.xul".
rv = nsChromeRegistry::Canonify(surl);
if (NS_FAILED(rv)) return rv;
surl.forget(result);
return NS_OK;
}
void
Location::SetPathname(const nsAString& aPathname,
nsIPrincipal& aSubjectPrincipal,
ErrorResult& aRv)
{
if (!CallerSubsumes(&aSubjectPrincipal)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
nsCOMPtr<nsIURI> uri;
aRv = GetURI(getter_AddRefs(uri));
if (NS_WARN_IF(aRv.Failed()) || !uri) {
return;
}
nsresult rv = NS_MutateURI(uri)
.SetFilePath(NS_ConvertUTF16toUTF8(aPathname))
.Finalize(uri);
if (NS_FAILED(rv)) {
return;
}
aRv = SetURI(uri);
}
void URL::SetHostname(const nsAString& aHostname) {
MOZ_ASSERT(mURI);
// nsStandardURL returns NS_ERROR_UNEXPECTED for an empty hostname
// The return code is silently ignored
mozilla::Unused << NS_MutateURI(mURI)
.SetHost(NS_ConvertUTF16toUTF8(aHostname))
.Finalize(mURI);
}
NS_IMETHODIMP nsExternalProtocolHandler::NewURI(const nsACString &aSpec,
const char *aCharset, // ignore charset info
nsIURI *aBaseURI,
nsIURI **_retval)
{
return NS_MutateURI(NS_SIMPLEURIMUTATOR_CONTRACTID)
.SetSpec(aSpec)
.Finalize(_retval);
}
void URL::SetSearchInternal(const nsAString& aSearch) {
MOZ_ASSERT(mURI);
// Ignore failures to be compatible with NS4.
Unused << NS_MutateURI(mURI)
.SetQuery(NS_ConvertUTF16toUTF8(aSearch))
.Finalize(mURI);
}
void URL::SetPathname(const nsAString& aPathname) {
MOZ_ASSERT(mURI);
// Do not throw!
Unused << NS_MutateURI(mURI)
.SetFilePath(NS_ConvertUTF16toUTF8(aPathname))
.Finalize(mURI);
}
NS_IMETHODIMP nsAddbookProtocolHandler::NewURI(
const nsACString &aSpec,
const char *aOriginCharset, // ignored
nsIURI *aBaseURI, nsIURI **_retval) {
nsresult rv;
nsCOMPtr<nsIURI> uri;
rv = NS_MutateURI(new nsAddbookUrl::Mutator()).SetSpec(aSpec).Finalize(uri);
NS_ENSURE_SUCCESS(rv, rv);
uri.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
nsGIOProtocolHandler::NewURI(const nsACString &aSpec,
const char *aOriginCharset,
nsIURI *aBaseURI,
nsIURI **aResult)
{
const nsCString flatSpec(aSpec);
LOG(("gio: NewURI [spec=%s]\n", flatSpec.get()));
if (!aBaseURI)
{
// XXX Is it good to support all GIO protocols?
if (!IsSupportedProtocol(flatSpec))
return NS_ERROR_UNKNOWN_PROTOCOL;
int32_t colon_location = flatSpec.FindChar(':');
if (colon_location <= 0)
return NS_ERROR_UNKNOWN_PROTOCOL;
// Verify that GIO supports this URI scheme.
bool uri_scheme_supported = false;
GVfs *gvfs = g_vfs_get_default();
if (!gvfs) {
g_warning("Cannot get GVfs object.");
return NS_ERROR_UNKNOWN_PROTOCOL;
}
const gchar* const * uri_schemes = g_vfs_get_supported_uri_schemes(gvfs);
while (*uri_schemes != nullptr) {
// While flatSpec ends with ':' the uri_scheme does not. Therefore do not
// compare last character.
if (StringHead(flatSpec, colon_location).Equals(*uri_schemes)) {
uri_scheme_supported = true;
break;
}
uri_schemes++;
}
if (!uri_scheme_supported) {
return NS_ERROR_UNKNOWN_PROTOCOL;
}
}
return NS_MutateURI(NS_STANDARDURLMUTATOR_CONTRACTID)
.Apply<nsIStandardURLMutator>(&nsIStandardURLMutator::Init,
nsIStandardURL::URLTYPE_STANDARD, -1,
flatSpec, aOriginCharset, aBaseURI,
nullptr)
.Finalize(aResult);
}
void URL::SetPort(const nsAString& aPort) {
nsresult rv;
nsAutoString portStr(aPort);
int32_t port = -1;
// nsIURI uses -1 as default value.
if (!portStr.IsEmpty()) {
port = portStr.ToInteger(&rv);
if (NS_FAILED(rv)) {
return;
}
}
Unused << NS_MutateURI(mURI).SetPort(port).Finalize(mURI);
}
void
Location::SetPort(const nsAString& aPort,
nsIPrincipal& aSubjectPrincipal,
ErrorResult& aRv)
{
if (!CallerSubsumes(&aSubjectPrincipal)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
nsCOMPtr<nsIURI> uri;
aRv = GetURI(getter_AddRefs(uri));
if (NS_WARN_IF(aRv.Failed() || !uri)) {
return;
}
// perhaps use nsReadingIterators at some point?
NS_ConvertUTF16toUTF8 portStr(aPort);
const char *buf = portStr.get();
int32_t port = -1;
if (!portStr.IsEmpty() && buf) {
if (*buf == ':') {
port = atol(buf+1);
}
else {
port = atol(buf);
}
}
aRv = NS_MutateURI(uri)
.SetPort(port)
.Finalize(uri);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
aRv = SetURI(uri);
}
void
Location::SetProtocol(const nsAString& aProtocol,
nsIPrincipal& aSubjectPrincipal,
ErrorResult& aRv)
{
if (!CallerSubsumes(&aSubjectPrincipal)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
nsCOMPtr<nsIURI> uri;
aRv = GetURI(getter_AddRefs(uri));
if (NS_WARN_IF(aRv.Failed()) || !uri) {
return;
}
nsAString::const_iterator start, end;
aProtocol.BeginReading(start);
aProtocol.EndReading(end);
nsAString::const_iterator iter(start);
Unused << FindCharInReadable(':', iter, end);
nsresult rv = NS_MutateURI(uri)
.SetScheme(NS_ConvertUTF16toUTF8(Substring(start, iter)))
.Finalize(uri);
if (NS_WARN_IF(NS_FAILED(rv))) {
// Oh, I wish nsStandardURL returned NS_ERROR_MALFORMED_URI for _all_ the
// malformed cases, not just some of them!
aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
return;
}
nsAutoCString newSpec;
aRv = uri->GetSpec(newSpec);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
// We may want a new URI class for the new URI, so recreate it:
rv = NS_NewURI(getter_AddRefs(uri), newSpec);
if (NS_FAILED(rv)) {
if (rv == NS_ERROR_MALFORMED_URI) {
rv = NS_ERROR_DOM_SYNTAX_ERR;
}
aRv.Throw(rv);
return;
}
bool isHttp;
aRv = uri->SchemeIs("http", &isHttp);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
bool isHttps;
aRv = uri->SchemeIs("https", &isHttps);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
if (!isHttp && !isHttps) {
// No-op, per spec.
return;
}
aRv = SetURI(uri);
}
void URL::SetHash(const nsAString& aHash) {
MOZ_ASSERT(mURI);
Unused
<< NS_MutateURI(mURI).SetRef(NS_ConvertUTF16toUTF8(aHash)).Finalize(mURI);
}
