/* -*- 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 "nsIObserver.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)

    MOZ_MUST_USE 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;
    }

    MOZ_MUST_USE NS_IMETHOD Read(nsIObjectInputStream* aStream) override {
      return BaseURIMutator<T>::InitFromInputStream(aStream);
    }

    MOZ_MUST_USE NS_IMETHOD Finalize(nsIURI** aURI) override {
      BaseURIMutator<T>::mURI.forget(aURI);
      return NS_OK;
    }

    MOZ_MUST_USE NS_IMETHOD SetSpec(const nsACString& aSpec,
                                    nsIURIMutator** aMutator) override {
      if (aMutator) {
        nsCOMPtr<nsIURIMutator> mutator = this;
        mutator.forget(aMutator);
      }
      return BaseURIMutator<T>::InitFromSpec(aSpec);
    }

    MOZ_MUST_USE 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 = uri.forget();
      return NS_OK;
    }

    MOZ_MUST_USE 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);
    }

    MOZ_MUST_USE 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);
    }

    MOZ_MUST_USE 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);
    }

    MOZ_MUST_USE 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); }

    MOZ_MUST_USE NS_IMETHOD MarkFileURL() override {
      mMarkedFileURL = true;
      return NS_OK;
    }

    MOZ_MUST_USE 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__