/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* 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 "mozilla/chrome/RegistryMessageUtils.h"

#include "mozilla/dom/ContentParent.h"

#include "mozilla/Unused.h"

#include "SubstitutingProtocolHandler.h"

#include "nsIChannel.h"

#include "nsIIOService.h"

#include "nsIFile.h"

#include "nsNetCID.h"

#include "nsNetUtil.h"

#include "nsReadableUtils.h"

#include "nsURLHelper.h"

#include "nsEscape.h"

using mozilla::dom::ContentParent;

namespace mozilla {

namespace net {

// Log module for Substituting Protocol logging. We keep the pre-existing module

// name of "nsResProtocol" to avoid disruption.

static LazyLogModule gResLog("nsResProtocol");

static NS_DEFINE_CID(kSubstitutingURLCID, NS_SUBSTITUTINGURL_CID);

//---------------------------------------------------------------------------------

// SubstitutingURL : overrides nsStandardURL::GetFile to provide nsIFile resolution

//---------------------------------------------------------------------------------

// The list of interfaces should be in sync with nsStandardURL

// Queries this list of interfaces. If none match, it queries mURI.

NS_IMPL_NSIURIMUTATOR_ISUPPORTS(SubstitutingURL::Mutator,

                                nsIURISetters,

                                nsIURIMutator,

                                nsIStandardURLMutator,

                                nsIURLMutator,

                                nsIFileURLMutator,

                                nsISerializable)

nsresult

SubstitutingURL::EnsureFile()

{

  nsAutoCString ourScheme;

  nsresult rv = GetScheme(ourScheme);

  NS_ENSURE_SUCCESS(rv, rv);

  // Get the handler associated with this scheme. It would be nice to just

  // pass this in when constructing SubstitutingURLs, but we need a generic

  // factory constructor.

  nsCOMPtr<nsIIOService> io = do_GetIOService(&rv);

  nsCOMPtr<nsIProtocolHandler> handler;

  rv = io->GetProtocolHandler(ourScheme.get(), getter_AddRefs(handler));

  NS_ENSURE_SUCCESS(rv, rv);

  nsCOMPtr<nsISubstitutingProtocolHandler> substHandler = do_QueryInterface(handler);

  MOZ_ASSERT(substHandler);

  nsAutoCString spec;

  rv = substHandler->ResolveURI(this, spec);

  if (NS_FAILED(rv))

    return rv;

  nsAutoCString scheme;

  rv = net_ExtractURLScheme(spec, scheme);

  if (NS_FAILED(rv))

    return rv;

  // Bug 585869:

  // In most cases, the scheme is jar if it's not file.

  // Regardless, net_GetFileFromURLSpec should be avoided

  // when the scheme isn't file.

  if (!scheme.EqualsLiteral("file"))

    return NS_ERROR_NO_INTERFACE;

  return net_GetFileFromURLSpec(spec, getter_AddRefs(mFile));

}

/* virtual */ nsStandardURL*

SubstitutingURL::StartClone()

{

  SubstitutingURL *clone = new SubstitutingURL();

  return clone;

}

NS_IMETHODIMP

SubstitutingURL::GetClassIDNoAlloc(nsCID *aClassIDNoAlloc)

{

  *aClassIDNoAlloc = kSubstitutingURLCID;

  return NS_OK;

}

SubstitutingProtocolHandler::SubstitutingProtocolHandler(const char* aScheme, uint32_t aFlags,

                                                         bool aEnforceFileOrJar)

  : mScheme(aScheme)

  , mSubstitutions(16)

  , mEnforceFileOrJar(aEnforceFileOrJar)

{

  mFlags.emplace(aFlags);

  ConstructInternal();

}

SubstitutingProtocolHandler::SubstitutingProtocolHandler(const char* aScheme)

  : mScheme(aScheme)

  , mSubstitutions(16)

  , mEnforceFileOrJar(true)

{

  ConstructInternal();

}

void

SubstitutingProtocolHandler::ConstructInternal()

{

  nsresult rv;

  mIOService = do_GetIOService(&rv);

  MOZ_RELEASE_ASSERT(NS_SUCCEEDED(rv) && mIOService);

}

//

// IPC marshalling.

//

nsresult

SubstitutingProtocolHandler::CollectSubstitutions(InfallibleTArray<SubstitutionMapping>& aMappings)

{

  for (auto iter = mSubstitutions.ConstIter(); !iter.Done(); iter.Next()) {

    SubstitutionEntry& entry = iter.Data();

    nsCOMPtr<nsIURI> uri = entry.baseURI;

    SerializedURI serialized;

    if (uri) {

      nsresult rv = uri->GetSpec(serialized.spec);

      NS_ENSURE_SUCCESS(rv, rv);

    }

    SubstitutionMapping substitution = { mScheme, nsCString(iter.Key()), serialized, entry.flags };

    aMappings.AppendElement(substitution);

  }

  return NS_OK;

}

nsresult

SubstitutingProtocolHandler::SendSubstitution(const nsACString& aRoot, nsIURI* aBaseURI, uint32_t aFlags)

{

  if (GeckoProcessType_Content == XRE_GetProcessType()) {

    return NS_OK;

  }

  nsTArray<ContentParent*> parents;

  ContentParent::GetAll(parents);

  if (!parents.Length()) {

    return NS_OK;

  }

  SubstitutionMapping mapping;

  mapping.scheme = mScheme;

  mapping.path = aRoot;

  if (aBaseURI) {

    nsresult rv = aBaseURI->GetSpec(mapping.resolvedURI.spec);

    NS_ENSURE_SUCCESS(rv, rv);

  }

  mapping.flags = aFlags;

  for (uint32_t i = 0; i < parents.Length(); i++) {

    Unused << parents[i]->SendRegisterChromeItem(mapping);

  }

  return NS_OK;

}

//----------------------------------------------------------------------------

// nsIProtocolHandler

//----------------------------------------------------------------------------

nsresult

SubstitutingProtocolHandler::GetScheme(nsACString &result)

{

  result = mScheme;

  return NS_OK;

}

nsresult

SubstitutingProtocolHandler::GetDefaultPort(int32_t *result)

{

  *result = -1;

  return NS_OK;

}

nsresult

SubstitutingProtocolHandler::GetProtocolFlags(uint32_t *result)

{

  if (mFlags.isNothing()) {

    NS_WARNING("Trying to get protocol flags the wrong way - use nsIProtocolHandlerWithDynamicFlags instead");

    return NS_ERROR_NOT_AVAILABLE;

  }

  *result = mFlags.ref();

  return NS_OK;

}

nsresult

SubstitutingProtocolHandler::NewURI(const nsACString &aSpec,

                                    const char *aCharset,

                                    nsIURI *aBaseURI,

                                    nsIURI **result)

{

  // unescape any %2f and %2e to make sure nsStandardURL coalesces them.

  // Later net_GetFileFromURLSpec() will do a full unescape and we want to

  // treat them the same way the file system will. (bugs 380994, 394075)

  nsAutoCString spec;

  const char *src = aSpec.BeginReading();

  const char *end = aSpec.EndReading();

  const char *last = src;

  spec.SetCapacity(aSpec.Length()+1);

  for ( ; src < end; ++src) {

    if (*src == '%' && (src < end-2) && *(src+1) == '2') {

      char ch = '\0';

      if (*(src+2) == 'f' || *(src+2) == 'F') {

        ch = '/';

      } else if (*(src+2) == 'e' || *(src+2) == 'E') {

        ch = '.';

      }

      if (ch) {

        if (last < src) {

          spec.Append(last, src-last);

        }

        spec.Append(ch);

        src += 2;

        last = src+1; // src will be incremented by the loop

      }

    }

  }

  if (last < src)

    spec.Append(last, src-last);

  nsCOMPtr<nsIURI> base(aBaseURI);

  return NS_MutateURI(new SubstitutingURL::Mutator())

    .Apply(NS_MutatorMethod(&nsIStandardURLMutator::Init,

                            nsIStandardURL::URLTYPE_STANDARD,

                            -1, spec, aCharset, base, nullptr))

    .Finalize(result);

}

nsresult

SubstitutingProtocolHandler::NewChannel2(nsIURI* uri,

                                         nsILoadInfo* aLoadInfo,

                                         nsIChannel** result)

{

  NS_ENSURE_ARG_POINTER(uri);

  NS_ENSURE_ARG_POINTER(aLoadInfo);

  nsAutoCString spec;

  nsresult rv = ResolveURI(uri, spec);

  NS_ENSURE_SUCCESS(rv, rv);

  nsCOMPtr<nsIURI> newURI;

  rv = NS_NewURI(getter_AddRefs(newURI), spec);

  NS_ENSURE_SUCCESS(rv, rv);

  // We don't want to allow the inner protocol handler to modify the result

  // principal URI since we want either |uri| or anything pre-set by upper

  // layers to prevail.

  nsCOMPtr<nsIURI> savedResultPrincipalURI;

  rv = aLoadInfo->GetResultPrincipalURI(getter_AddRefs(savedResultPrincipalURI));

  NS_ENSURE_SUCCESS(rv, rv);

  rv = NS_NewChannelInternal(result, newURI, aLoadInfo);

  NS_ENSURE_SUCCESS(rv, rv);

  rv = aLoadInfo->SetResultPrincipalURI(savedResultPrincipalURI);

  NS_ENSURE_SUCCESS(rv, rv);

  rv = (*result)->SetOriginalURI(uri);

  NS_ENSURE_SUCCESS(rv, rv);

  return SubstituteChannel(uri, aLoadInfo, result);

}

nsresult

SubstitutingProtocolHandler::NewChannel(nsIURI* uri, nsIChannel* *result)

{

  return NewChannel2(uri, nullptr, result);

}

nsresult

SubstitutingProtocolHandler::AllowPort(int32_t port, const char *scheme, bool *_retval)

{

  // don't override anything.

  *_retval = false;

  return NS_OK;

}

//----------------------------------------------------------------------------

// nsISubstitutingProtocolHandler

//----------------------------------------------------------------------------

nsresult

SubstitutingProtocolHandler::SetSubstitution(const nsACString& root, nsIURI *baseURI)

{

  // Add-ons use this API but they should not be able to make anything

  // content-accessible.

  return SetSubstitutionWithFlags(root, baseURI, 0);

}

nsresult

SubstitutingProtocolHandler::SetSubstitutionWithFlags(const nsACString& origRoot, nsIURI *baseURI, uint32_t flags)

{

  nsAutoCString root;

  ToLowerCase(origRoot, root);

  if (!baseURI) {

    mSubstitutions.Remove(root);

    NotifyObservers(root, baseURI);

    return SendSubstitution(root, baseURI, flags);

  }

  // If baseURI isn't a same-scheme URI, we can set the substitution immediately.

  nsAutoCString scheme;

  nsresult rv = baseURI->GetScheme(scheme);

  NS_ENSURE_SUCCESS(rv, rv);

  if (!scheme.Equals(mScheme)) {

    if (mEnforceFileOrJar && !scheme.EqualsLiteral("file") && !scheme.EqualsLiteral("jar")

        && !scheme.EqualsLiteral("app")) {

      NS_WARNING("Refusing to create substituting URI to non-file:// target");

      return NS_ERROR_INVALID_ARG;

    }

    SubstitutionEntry& entry = mSubstitutions.GetOrInsert(root);

    entry.baseURI = baseURI;

    entry.flags = flags;

    NotifyObservers(root, baseURI);

    return SendSubstitution(root, baseURI, flags);

  }

  // baseURI is a same-type substituting URI, let's resolve it first.

  nsAutoCString newBase;

  rv = ResolveURI(baseURI, newBase);

  NS_ENSURE_SUCCESS(rv, rv);

  nsCOMPtr<nsIURI> newBaseURI;

  rv = mIOService->NewURI(newBase, nullptr, nullptr, getter_AddRefs(newBaseURI));

  NS_ENSURE_SUCCESS(rv, rv);

  SubstitutionEntry& entry = mSubstitutions.GetOrInsert(root);

  entry.baseURI = newBaseURI;

  entry.flags = flags;

  NotifyObservers(root, baseURI);

  return SendSubstitution(root, newBaseURI, flags);

}

nsresult

SubstitutingProtocolHandler::GetSubstitution(const nsACString& origRoot, nsIURI **result)

{

  NS_ENSURE_ARG_POINTER(result);

  nsAutoCString root;

  ToLowerCase(origRoot, root);

  SubstitutionEntry entry;

  if (mSubstitutions.Get(root, &entry)) {

    nsCOMPtr<nsIURI> baseURI = entry.baseURI;

    baseURI.forget(result);

    return NS_OK;

  }

  uint32_t flags;

  return GetSubstitutionInternal(root, result, &flags);

}

nsresult

SubstitutingProtocolHandler::GetSubstitutionFlags(const nsACString& root, uint32_t* flags)

{

#ifdef DEBUG

  nsAutoCString lcRoot;

  ToLowerCase(root, lcRoot);

  MOZ_ASSERT(root.Equals(lcRoot), "GetSubstitutionFlags should never receive mixed-case root name");

#endif

  *flags = 0;

  SubstitutionEntry entry;

  if (mSubstitutions.Get(root, &entry)) {

    *flags = entry.flags;

    return NS_OK;

  }

  nsCOMPtr<nsIURI> baseURI;

  return GetSubstitutionInternal(root, getter_AddRefs(baseURI), flags);

}

nsresult

SubstitutingProtocolHandler::HasSubstitution(const nsACString& origRoot, bool *result)

{

  NS_ENSURE_ARG_POINTER(result);

  nsAutoCString root;

  ToLowerCase(origRoot, root);

  *result = HasSubstitution(root);

  return NS_OK;

}

nsresult

SubstitutingProtocolHandler::ResolveURI(nsIURI *uri, nsACString &result)

{

  nsresult rv;

  nsAutoCString host;

  nsAutoCString path;

  nsAutoCString pathname;

  nsCOMPtr<nsIURL> url = do_QueryInterface(uri);

  if (!url) {

    return NS_ERROR_MALFORMED_URI;

  }

  rv = uri->GetAsciiHost(host);

  if (NS_FAILED(rv)) return rv;

  rv = uri->GetPathQueryRef(path);

  if (NS_FAILED(rv)) return rv;

  rv = url->GetFilePath(pathname);

  if (NS_FAILED(rv)) return rv;

  if (ResolveSpecialCases(host, path, pathname, result)) {

    return NS_OK;

  }

  nsCOMPtr<nsIURI> baseURI;

  rv = GetSubstitution(host, getter_AddRefs(baseURI));

  if (NS_FAILED(rv)) return rv;

  // Unescape the path so we can perform some checks on it.

  NS_UnescapeURL(pathname);

  if (pathname.FindChar('\\') != -1) {

    return NS_ERROR_MALFORMED_URI;

  }

  // Some code relies on an empty path resolving to a file rather than a

  // directory.

  NS_ASSERTION(path.CharAt(0) == '/', "Path must begin with '/'");

  if (path.Length() == 1) {

    rv = baseURI->GetSpec(result);

  } else {

    // Make sure we always resolve the path as file-relative to our target URI.

    // When the baseURI is a nsIFileURL, and the directory it points to doesn't

    // exist, it doesn't end with a /. In that case, a file-relative resolution

    // is going to pick something in the parent directory, so we resolve using

    // an absolute path derived from the full path in that case.

    nsCOMPtr<nsIFileURL> baseDir = do_QueryInterface(baseURI);

    if (baseDir) {

      nsAutoCString basePath;

      rv = baseURI->GetFilePath(basePath);

      if (NS_SUCCEEDED(rv) && !StringEndsWith(basePath, NS_LITERAL_CSTRING("/"))) {

        // Cf. the assertion above, path already starts with a /, so prefixing

        // with a string that doesn't end with one will leave us wit the right

        // amount of /.

        path.Insert(basePath, 0);

      } else {

        // Allow to fall through below.

        baseDir = nullptr;

      }

    }

    if (!baseDir) {

      path.Insert('.', 0);

    }

    rv = baseURI->Resolve(path, result);

  }

  if (NS_WARN_IF(NS_FAILED(rv))) {

    return rv;

  }

  if (MOZ_LOG_TEST(gResLog, LogLevel::Debug)) {

    nsAutoCString spec;

    uri->GetAsciiSpec(spec);

    MOZ_LOG(gResLog, LogLevel::Debug, ("%s\n -> %s\n", spec.get(), PromiseFlatCString(result).get()));

  }

  return rv;

}

nsresult

SubstitutingProtocolHandler::AddObserver(nsISubstitutionObserver* aObserver)

{

  NS_ENSURE_ARG(aObserver);

  if (mObservers.Contains(aObserver)) {

    return NS_ERROR_DUPLICATE_HANDLE;

  }

  mObservers.AppendElement(aObserver);

  return NS_OK;

}

nsresult

SubstitutingProtocolHandler::RemoveObserver(nsISubstitutionObserver* aObserver)

{

  NS_ENSURE_ARG(aObserver);

  if (!mObservers.Contains(aObserver)) {

    return NS_ERROR_INVALID_ARG;

  }

  mObservers.RemoveElement(aObserver);

  return NS_OK;

}

void

SubstitutingProtocolHandler::NotifyObservers(const nsACString& aRoot,

                                             nsIURI* aBaseURI)

{

  for (size_t i = 0; i < mObservers.Length(); ++i) {

    mObservers[i]->OnSetSubstitution(aRoot, aBaseURI);

  }

}

} // namespace net

} // namespace mozilla