void
Location::GetHost(nsAString& aHost,
nsIPrincipal& aSubjectPrincipal,
ErrorResult& aRv)
{
if (!CallerSubsumes(&aSubjectPrincipal)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
aHost.Truncate();
nsCOMPtr<nsIURI> uri;
nsresult result;
result = GetURI(getter_AddRefs(uri), true);
if (uri) {
nsAutoCString hostport;
result = uri->GetHostPort(hostport);
if (NS_SUCCEEDED(result)) {
AppendUTF8toUTF16(hostport, aHost);
}
}
}
void
Location::GetSearch(nsAString& aSearch,
nsIPrincipal& aSubjectPrincipal,
ErrorResult& aRv)
{
if (!CallerSubsumes(&aSubjectPrincipal)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
aSearch.SetLength(0);
nsCOMPtr<nsIURI> uri;
nsresult result = NS_OK;
result = GetURI(getter_AddRefs(uri));
nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
if (url) {
nsAutoCString search;
result = url->GetQuery(search);
if (NS_SUCCEEDED(result) && !search.IsEmpty()) {
aSearch.Assign(char16_t('?'));
AppendUTF8toUTF16(search, aSearch);
}
}
}
void
Location::Assign(const nsAString& aUrl,
nsIPrincipal& aSubjectPrincipal,
ErrorResult& aRv)
{
if (!CallerSubsumes(&aSubjectPrincipal)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
if (JSContext *cx = nsContentUtils::GetCurrentJSContext()) {
aRv = SetHrefWithContext(cx, aUrl, false);
return;
}
nsAutoString oldHref;
aRv = GetHref(oldHref);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
nsCOMPtr<nsIURI> oldUri;
aRv = NS_NewURI(getter_AddRefs(oldUri), oldHref);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
if (oldUri) {
aRv = SetHrefWithBase(aUrl, oldUri, false);
}
}
NS_IMETHODIMP
nsLocation::GetPort(nsAString& aPort)
{
if (!CallerSubsumes())
return NS_ERROR_DOM_SECURITY_ERR;
aPort.SetLength(0);
nsCOMPtr<nsIURI> uri;
nsresult result = NS_OK;
result = GetURI(getter_AddRefs(uri), true);
if (uri) {
int32_t port;
result = uri->GetPort(&port);
if (NS_SUCCEEDED(result) && -1 != port) {
nsAutoString portStr;
portStr.AppendInt(port);
aPort.Append(portStr);
}
// Don't propagate this exception to caller
result = NS_OK;
}
return result;
}
NS_IMETHODIMP
nsLocation::GetHref(nsAString& aHref)
{
if (!CallerSubsumes())
return NS_ERROR_DOM_SECURITY_ERR;
aHref.Truncate();
nsCOMPtr<nsIURI> uri;
nsresult result;
result = GetURI(getter_AddRefs(uri));
if (uri) {
nsAutoCString uriString;
result = uri->GetSpec(uriString);
if (NS_SUCCEEDED(result)) {
AppendUTF8toUTF16(uriString, aHref);
}
}
return result;
}
NS_IMETHODIMP
nsLocation::GetPathname(nsAString& aPathname)
{
if (!CallerSubsumes())
return NS_ERROR_DOM_SECURITY_ERR;
aPathname.Truncate();
nsCOMPtr<nsIURI> uri;
nsresult result = NS_OK;
result = GetURI(getter_AddRefs(uri));
nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
if (url) {
nsAutoCString file;
result = url->GetFilePath(file);
if (NS_SUCCEEDED(result)) {
AppendUTF8toUTF16(file, aPathname);
}
}
return result;
}
void
Location::GetOrigin(nsAString& aOrigin,
nsIPrincipal& aSubjectPrincipal,
ErrorResult& aRv)
{
if (!CallerSubsumes(&aSubjectPrincipal)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
aOrigin.Truncate();
nsCOMPtr<nsIURI> uri;
aRv = GetURI(getter_AddRefs(uri), true);
if (NS_WARN_IF(aRv.Failed()) || !uri) {
return;
}
nsAutoString origin;
aRv = nsContentUtils::GetUTFOrigin(uri, origin);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
aOrigin = origin;
}
NS_IMETHODIMP
nsLocation::GetHostname(nsAString& aHostname)
{
if (!CallerSubsumes())
return NS_ERROR_DOM_SECURITY_ERR;
aHostname.Truncate();
nsCOMPtr<nsIURI> uri;
nsresult result;
result = GetURI(getter_AddRefs(uri), true);
if (uri) {
nsAutoCString host;
result = uri->GetHost(host);
if (NS_SUCCEEDED(result)) {
AppendUTF8toUTF16(host, aHostname);
}
}
return NS_OK;
}
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);
}
NS_IMETHODIMP
nsLocation::GetProtocol(nsAString& aProtocol)
{
if (!CallerSubsumes())
return NS_ERROR_DOM_SECURITY_ERR;
aProtocol.SetLength(0);
nsCOMPtr<nsIURI> uri;
nsresult result = NS_OK;
result = GetURI(getter_AddRefs(uri));
if (uri) {
nsAutoCString protocol;
result = uri->GetScheme(protocol);
if (NS_SUCCEEDED(result)) {
CopyASCIItoUTF16(protocol, aProtocol);
aProtocol.Append(PRUnichar(':'));
}
}
return result;
}
NS_IMETHODIMP
nsLocation::GetSearch(nsAString& aSearch)
{
if (!CallerSubsumes())
return NS_ERROR_DOM_SECURITY_ERR;
aSearch.SetLength(0);
nsCOMPtr<nsIURI> uri;
nsresult result = NS_OK;
result = GetURI(getter_AddRefs(uri));
nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
if (url) {
nsAutoCString search;
result = url->GetQuery(search);
if (NS_SUCCEEDED(result) && !search.IsEmpty()) {
aSearch.Assign(PRUnichar('?'));
AppendUTF8toUTF16(search, aSearch);
}
}
return NS_OK;
}
void
Location::GetPort(nsAString& aPort,
nsIPrincipal& aSubjectPrincipal,
ErrorResult& aRv)
{
if (!CallerSubsumes(&aSubjectPrincipal)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
aPort.SetLength(0);
nsCOMPtr<nsIURI> uri;
aRv = GetURI(getter_AddRefs(uri), true);
if (NS_WARN_IF(aRv.Failed()) || !uri) {
return;
}
int32_t port;
nsresult result = uri->GetPort(&port);
// Don't propagate this exception to caller
if (NS_SUCCEEDED(result) && -1 != port) {
nsAutoString portStr;
portStr.AppendInt(port);
aPort.Append(portStr);
}
}
void
Location::GetProtocol(nsAString& aProtocol,
nsIPrincipal& aSubjectPrincipal,
ErrorResult& aRv)
{
if (!CallerSubsumes(&aSubjectPrincipal)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
aProtocol.SetLength(0);
nsCOMPtr<nsIURI> uri;
aRv = GetURI(getter_AddRefs(uri));
if (NS_WARN_IF(aRv.Failed()) || !uri) {
return;
}
nsAutoCString protocol;
aRv = uri->GetScheme(protocol);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
CopyASCIItoUTF16(protocol, aProtocol);
aProtocol.Append(char16_t(':'));
}
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
Location::GetPathname(nsAString& aPathname,
nsIPrincipal& aSubjectPrincipal,
ErrorResult& aRv)
{
if (!CallerSubsumes(&aSubjectPrincipal)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
aPathname.Truncate();
nsCOMPtr<nsIURI> uri;
aRv = GetURI(getter_AddRefs(uri));
if (NS_WARN_IF(aRv.Failed()) || !uri) {
return;
}
nsAutoCString file;
aRv = uri->GetFilePath(file);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
AppendUTF8toUTF16(file, aPathname);
}
NS_IMETHODIMP
nsLocation::SetPort(const nsAString& aPort)
{
if (!CallerSubsumes())
return NS_ERROR_DOM_SECURITY_ERR;
nsCOMPtr<nsIURI> uri;
nsresult rv = GetWritableURI(getter_AddRefs(uri));
if (uri) {
// perhaps use nsReadingIterators at some point?
NS_ConvertUTF16toUTF8 portStr(aPort);
const char *buf = portStr.get();
int32_t port = -1;
if (buf) {
if (*buf == ':') {
port = atol(buf+1);
}
else {
port = atol(buf);
}
}
rv = uri->SetPort(port);
if (NS_SUCCEEDED(rv)) {
SetURI(uri);
}
}
return rv;
}
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);
}
NS_IMETHODIMP
nsLocation::GetHash(nsAString& aHash)
{
if (!CallerSubsumes())
return NS_ERROR_DOM_SECURITY_ERR;
aHash.SetLength(0);
nsCOMPtr<nsIURI> uri;
nsresult rv = GetURI(getter_AddRefs(uri));
if (NS_FAILED(rv) || !uri) {
return rv;
}
nsAutoCString ref;
nsAutoString unicodeRef;
rv = uri->GetRef(ref);
if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsITextToSubURI> textToSubURI(
do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv));
if (NS_SUCCEEDED(rv)) {
nsAutoCString charset;
uri->GetOriginCharset(charset);
rv = textToSubURI->UnEscapeURIForUI(charset, ref, unicodeRef);
}
if (NS_FAILED(rv)) {
// Oh, well. No intl here!
NS_UnescapeURL(ref);
CopyASCIItoUTF16(ref, unicodeRef);
rv = NS_OK;
}
}
if (NS_SUCCEEDED(rv) && !unicodeRef.IsEmpty()) {
aHash.Assign(PRUnichar('#'));
aHash.Append(unicodeRef);
}
if (aHash == mCachedHash) {
// Work around ShareThis stupidly polling location.hash every
// 5ms all the time by handing out the same exact string buffer
// we handed out last time.
aHash = mCachedHash;
} else {
mCachedHash = aHash;
}
return rv;
}
NS_IMETHODIMP
nsLocation::Reload(bool aForceget)
{
if (!CallerSubsumes())
return NS_ERROR_DOM_SECURITY_ERR;
nsresult rv;
nsCOMPtr<nsIDocShell> docShell(do_QueryReferent(mDocShell));
nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(docShell));
nsCOMPtr<nsPIDOMWindow> window(do_GetInterface(docShell));
if (window && window->IsHandlingResizeEvent()) {
// location.reload() was called on a window that is handling a
// resize event. Sites do this since Netscape 4.x needed it, but
// we don't, and it's a horrible experience for nothing. In stead
// of reloading the page, just clear style data and reflow the
// page since some sites may use this trick to work around gecko
// reflow bugs, and this should have the same effect.
nsCOMPtr<nsIDocument> doc(do_QueryInterface(window->GetExtantDocument()));
nsIPresShell *shell;
nsPresContext *pcx;
if (doc && (shell = doc->GetShell()) && (pcx = shell->GetPresContext())) {
pcx->RebuildAllStyleData(NS_STYLE_HINT_REFLOW);
}
return NS_OK;
}
if (webNav) {
uint32_t reloadFlags = nsIWebNavigation::LOAD_FLAGS_NONE;
if (aForceget) {
reloadFlags = nsIWebNavigation::LOAD_FLAGS_BYPASS_CACHE |
nsIWebNavigation::LOAD_FLAGS_BYPASS_PROXY;
}
rv = webNav->Reload(reloadFlags);
if (rv == NS_BINDING_ABORTED) {
// This happens when we attempt to reload a POST result and the user says
// no at the "do you want to reload?" prompt. Don't propagate this one
// back to callers.
rv = NS_OK;
}
} else {
rv = NS_ERROR_FAILURE;
}
return rv;
}
NS_IMETHODIMP
nsLocation::SetProtocol(const nsAString& aProtocol)
{
if (!CallerSubsumes())
return NS_ERROR_DOM_SECURITY_ERR;
nsCOMPtr<nsIURI> uri;
nsresult rv = GetWritableURI(getter_AddRefs(uri));
if (uri) {
rv = uri->SetScheme(NS_ConvertUTF16toUTF8(aProtocol));
if (NS_SUCCEEDED(rv)) {
SetURI(uri);
}
}
return rv;
}
void
Location::GetHostname(nsAString& aHostname,
nsIPrincipal& aSubjectPrincipal,
ErrorResult& aRv)
{
if (!CallerSubsumes(&aSubjectPrincipal)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
aHostname.Truncate();
nsCOMPtr<nsIURI> uri;
GetURI(getter_AddRefs(uri), true);
if (uri) {
nsContentUtils::GetHostOrIPv6WithBrackets(uri, aHostname);
}
}
NS_IMETHODIMP
nsLocation::SetSearch(const nsAString& aSearch)
{
if (!CallerSubsumes())
return NS_ERROR_DOM_SECURITY_ERR;
nsCOMPtr<nsIURI> uri;
nsresult rv = GetWritableURI(getter_AddRefs(uri));
nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
if (url) {
rv = url->SetQuery(NS_ConvertUTF16toUTF8(aSearch));
if (NS_SUCCEEDED(rv)) {
SetURI(uri);
}
}
return rv;
}
void
Location::GetHash(nsAString& aHash,
nsIPrincipal& aSubjectPrincipal,
ErrorResult& aRv)
{
if (!CallerSubsumes(&aSubjectPrincipal)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
aHash.SetLength(0);
nsCOMPtr<nsIURI> uri;
aRv = GetURI(getter_AddRefs(uri));
if (NS_WARN_IF(aRv.Failed()) || !uri) {
return;
}
nsAutoCString ref;
nsAutoString unicodeRef;
aRv = uri->GetRef(ref);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
if (!ref.IsEmpty()) {
aHash.Assign(char16_t('#'));
AppendUTF8toUTF16(ref, aHash);
}
if (aHash == mCachedHash) {
// Work around ShareThis stupidly polling location.hash every
// 5ms all the time by handing out the same exact string buffer
// we handed out last time.
aHash = mCachedHash;
} else {
mCachedHash = aHash;
}
}
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);
}
NS_IMETHODIMP
nsLocation::Assign(const nsAString& aUrl)
{
if (!CallerSubsumes())
return NS_ERROR_DOM_SECURITY_ERR;
nsAutoString oldHref;
nsresult result = NS_OK;
result = GetHref(oldHref);
if (NS_SUCCEEDED(result)) {
nsCOMPtr<nsIURI> oldUri;
result = NS_NewURI(getter_AddRefs(oldUri), oldHref);
if (oldUri) {
result = SetHrefWithBase(aUrl, oldUri, false);
}
}
return result;
}
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);
}