Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 591 insertions, 0 deletions

diff --git a/comm/mailnews/addrbook/src/nsLDAPURL.cpp b/comm/mailnews/addrbook/src/nsLDAPURL.cpp
new file mode 100644
index 0000000000..90e4e370e4
--- /dev/null
+++ b/comm/mailnews/addrbook/src/nsLDAPURL.cpp
@@ -0,0 +1,591 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#include "nsLDAPURL.h"
+#include "netCore.h"
+#include "plstr.h"
+#include "nsCOMPtr.h"
+#include "nsNetCID.h"
+#include "nsComponentManagerUtils.h"
+#include "nsIStandardURL.h"
+#include "nsMsgUtils.h"
+#include "nsUnicharUtils.h"
+#include "mozilla/Encoding.h"
+
+// The two schemes we support, LDAP and LDAPS
+//
+constexpr auto LDAP_SCHEME = "ldap"_ns;
+constexpr auto LDAP_SSL_SCHEME = "ldaps"_ns;
+
+NS_IMPL_ISUPPORTS(nsLDAPURL, nsILDAPURL, nsIURI)
+
+nsLDAPURL::nsLDAPURL() : mScope(SCOPE_BASE), mOptions(0) {}
+
+nsLDAPURL::~nsLDAPURL() {}
+
+nsresult nsLDAPURL::Init(uint32_t aUrlType, int32_t aDefaultPort,
+                         const nsACString& aSpec, const char* aOriginCharset,
+                         nsIURI* aBaseURI) {
+  nsresult rv;
+  nsCOMPtr<nsIURI> base(aBaseURI);
+  rv = NS_MutateURI(NS_STANDARDURLMUTATOR_CONTRACTID)
+           .Apply(&nsIStandardURLMutator::Init,
+                  nsIStandardURL::URLTYPE_STANDARD, aDefaultPort,
+                  PromiseFlatCString(aSpec), aOriginCharset, aBaseURI, nullptr)
+           .Finalize(mBaseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Now get the spec from the mBaseURL in case it was a relative one
+  nsCString spec;
+  rv = mBaseURL->GetSpec(spec);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return SetSpecInternal(spec);
+}
+
+void nsLDAPURL::GetPathInternal(nsCString& aPath) {
+  aPath.Assign('/');
+
+  if (!mDN.IsEmpty()) aPath.Append(mDN);
+
+  if (!mAttributes.IsEmpty()) aPath.Append('?');
+
+  // If mAttributes isn't empty, cut off the internally stored commas at start
+  // and end, and append to the path.
+  if (!mAttributes.IsEmpty())
+    aPath.Append(Substring(mAttributes, 1, mAttributes.Length() - 2));
+
+  if (mScope || !mFilter.IsEmpty()) {
+    aPath.Append((mAttributes.IsEmpty() ? "??" : "?"));
+    if (mScope) {
+      if (mScope == SCOPE_ONELEVEL)
+        aPath.Append("one");
+      else if (mScope == SCOPE_SUBTREE)
+        aPath.Append("sub");
+    }
+    if (!mFilter.IsEmpty()) {
+      aPath.Append('?');
+      aPath.Append(mFilter);
+    }
+  }
+}
+
+nsresult nsLDAPURL::SetPathInternal(const nsCString& aPath) {
+  nsCOMPtr<nsILDAPURLParser> parser =
+      do_CreateInstance("@mozilla.org/network/ldap-url-parser;1");
+  nsCOMPtr<nsILDAPURLParserResult> parserResult;
+  nsresult rv = parser->Parse(aPath, getter_AddRefs(parserResult));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  parserResult->GetDn(mDN);
+  parserResult->GetScope(&mScope);
+  parserResult->GetFilter(mFilter);
+  parserResult->GetOptions(&mOptions);
+
+  nsCString attributes;
+  parserResult->GetAttributes(attributes);
+  mAttributes.Truncate();
+  if (!attributes.IsEmpty()) {
+    // Always start and end with a comma if not empty.
+    mAttributes.Append(',');
+    mAttributes.Append(attributes);
+    mAttributes.Append(',');
+  }
+
+  return NS_OK;
+}
+
+// A string representation of the URI. Setting the spec
+// causes the new spec to be parsed, initializing the URI. Setting
+// the spec (or any of the accessors) causes also any currently
+// open streams on the URI's channel to be closed.
+
+NS_IMETHODIMP
+nsLDAPURL::GetSpec(nsACString& _retval) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  return mBaseURL->GetSpec(_retval);
+}
+
+nsresult nsLDAPURL::SetSpecInternal(const nsACString& aSpec) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  // Cache the original spec in case we don't like what we've been passed and
+  // need to reset ourselves.
+  nsCString originalSpec;
+  nsresult rv = mBaseURL->GetSpec(originalSpec);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = NS_MutateURI(mBaseURL).SetSpec(aSpec).Finalize(mBaseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = SetPathInternal(PromiseFlatCString(aSpec));
+  if (NS_FAILED(rv)) {
+    nsresult rv2 =
+        NS_MutateURI(mBaseURL).SetSpec(originalSpec).Finalize(mBaseURL);
+    NS_ENSURE_SUCCESS(rv2, rv2);
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP nsLDAPURL::GetPrePath(nsACString& _retval) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  return mBaseURL->GetPrePath(_retval);
+}
+
+NS_IMETHODIMP nsLDAPURL::GetScheme(nsACString& _retval) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  return mBaseURL->GetScheme(_retval);
+}
+
+nsresult nsLDAPURL::SetScheme(const nsACString& aScheme) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  if (aScheme.Equals(LDAP_SCHEME, nsCaseInsensitiveCStringComparator))
+    mOptions &= ~OPT_SECURE;
+  else if (aScheme.Equals(LDAP_SSL_SCHEME, nsCaseInsensitiveCStringComparator))
+    mOptions |= OPT_SECURE;
+  else
+    return NS_ERROR_MALFORMED_URI;
+
+  return NS_MutateURI(mBaseURL).SetScheme(aScheme).Finalize(mBaseURL);
+}
+
+NS_IMETHODIMP
+nsLDAPURL::GetUserPass(nsACString& _retval) {
+  _retval.Truncate();
+  return NS_OK;
+}
+
+nsresult nsLDAPURL::SetUserPass(const nsACString& aUserPass) { return NS_OK; }
+
+NS_IMETHODIMP
+nsLDAPURL::GetUsername(nsACString& _retval) {
+  _retval.Truncate();
+  return NS_OK;
+}
+
+nsresult nsLDAPURL::SetUsername(const nsACString& aUsername) { return NS_OK; }
+
+NS_IMETHODIMP
+nsLDAPURL::GetPassword(nsACString& _retval) {
+  _retval.Truncate();
+  return NS_OK;
+}
+
+nsresult nsLDAPURL::SetPassword(const nsACString& aPassword) { return NS_OK; }
+
+NS_IMETHODIMP
+nsLDAPURL::GetHostPort(nsACString& _retval) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  return mBaseURL->GetHostPort(_retval);
+}
+
+nsresult nsLDAPURL::SetHostPort(const nsACString& aHostPort) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  return NS_MutateURI(mBaseURL).SetHostPort(aHostPort).Finalize(mBaseURL);
+}
+
+NS_IMETHODIMP
+nsLDAPURL::GetHost(nsACString& _retval) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  return mBaseURL->GetHost(_retval);
+}
+
+nsresult nsLDAPURL::SetHost(const nsACString& aHost) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  return NS_MutateURI(mBaseURL).SetHost(aHost).Finalize(mBaseURL);
+}
+
+NS_IMETHODIMP
+nsLDAPURL::GetPort(int32_t* _retval) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  return mBaseURL->GetPort(_retval);
+}
+
+nsresult nsLDAPURL::SetPort(int32_t aPort) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  return NS_MutateURI(mBaseURL).SetPort(aPort).Finalize(mBaseURL);
+}
+
+NS_IMETHODIMP nsLDAPURL::GetPathQueryRef(nsACString& _retval) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  return mBaseURL->GetPathQueryRef(_retval);
+}
+
+nsresult nsLDAPURL::SetPathQueryRef(const nsACString& aPath) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  nsresult rv = SetPathInternal(PromiseFlatCString(aPath));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_MutateURI(mBaseURL).SetPathQueryRef(aPath).Finalize(mBaseURL);
+}
+
+NS_IMETHODIMP nsLDAPURL::GetAsciiSpec(nsACString& _retval) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  // XXX handle extra items?
+  return mBaseURL->GetAsciiSpec(_retval);
+}
+
+NS_IMETHODIMP nsLDAPURL::GetAsciiHost(nsACString& _retval) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  return mBaseURL->GetAsciiHost(_retval);
+}
+
+NS_IMETHODIMP
+nsLDAPURL::GetAsciiHostPort(nsACString& _retval) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  return mBaseURL->GetAsciiHostPort(_retval);
+}
+
+// boolean equals (in nsIURI other)
+// (based on nsSimpleURI::Equals)
+NS_IMETHODIMP nsLDAPURL::Equals(nsIURI* other, bool* _retval) {
+  *_retval = false;
+  if (other) {
+    nsresult rv;
+    nsCOMPtr<nsILDAPURL> otherURL(do_QueryInterface(other, &rv));
+    if (NS_SUCCEEDED(rv)) {
+      nsAutoCString thisSpec, otherSpec;
+      uint32_t otherOptions;
+
+      rv = GetSpec(thisSpec);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = otherURL->GetSpec(otherSpec);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = otherURL->GetOptions(&otherOptions);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      if (thisSpec == otherSpec && mOptions == otherOptions) *_retval = true;
+    }
+  }
+  return NS_OK;
+}
+
+// boolean schemeIs(in const char * scheme);
+//
+NS_IMETHODIMP nsLDAPURL::SchemeIs(const char* aScheme, bool* aEquals) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  return mBaseURL->SchemeIs(aScheme, aEquals);
+}
+
+// nsIURI clone ();
+//
+nsresult nsLDAPURL::Clone(nsIURI** aResult) {
+  NS_ENSURE_ARG_POINTER(aResult);
+
+  RefPtr<nsLDAPURL> clone = new nsLDAPURL();
+
+  clone->mDN = mDN;
+  clone->mScope = mScope;
+  clone->mFilter = mFilter;
+  clone->mOptions = mOptions;
+  clone->mAttributes = mAttributes;
+
+  nsresult rv = NS_MutateURI(mBaseURL).Finalize(clone->mBaseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  clone.forget(aResult);
+  return NS_OK;
+}
+
+// string resolve (in string relativePath);
+//
+NS_IMETHODIMP nsLDAPURL::Resolve(const nsACString& relativePath,
+                                 nsACString& _retval) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+// The following attributes come from nsILDAPURL
+
+// attribute AUTF8String dn;
+//
+NS_IMETHODIMP nsLDAPURL::GetDn(nsACString& _retval) {
+  _retval.Assign(mDN);
+  return NS_OK;
+}
+NS_IMETHODIMP nsLDAPURL::SetDn(const nsACString& aDn) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  mDN.Assign(aDn);
+
+  // Now get the current path
+  nsCString newPath;
+  GetPathInternal(newPath);
+
+  // and update the base url
+  return NS_MutateURI(mBaseURL).SetPathQueryRef(newPath).Finalize(mBaseURL);
+}
+
+NS_IMETHODIMP nsLDAPURL::GetAttributes(nsACString& aAttributes) {
+  if (mAttributes.IsEmpty()) {
+    aAttributes.Truncate();
+    return NS_OK;
+  }
+
+  NS_ASSERTION(
+      mAttributes[0] == ',' && mAttributes[mAttributes.Length() - 1] == ',',
+      "mAttributes does not begin and end with a comma");
+
+  // We store the string internally with comma before and after, so strip
+  // them off here.
+  aAttributes = Substring(mAttributes, 1, mAttributes.Length() - 2);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLDAPURL::SetAttributes(const nsACString& aAttributes) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  if (aAttributes.IsEmpty())
+    mAttributes.Truncate();
+  else {
+    // We need to make sure we start off the string with a comma.
+    if (aAttributes[0] != ',') mAttributes = ',';
+
+    mAttributes.Append(aAttributes);
+
+    // Also end with a comma if appropriate.
+    if (mAttributes[mAttributes.Length() - 1] != ',') mAttributes.Append(',');
+  }
+
+  // Now get the current path
+  nsCString newPath;
+  GetPathInternal(newPath);
+
+  // and update the base url
+  return NS_MutateURI(mBaseURL).SetPathQueryRef(newPath).Finalize(mBaseURL);
+}
+
+NS_IMETHODIMP nsLDAPURL::AddAttribute(const nsACString& aAttribute) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  if (mAttributes.IsEmpty()) {
+    mAttributes = ',';
+    mAttributes.Append(aAttribute);
+    mAttributes.Append(',');
+  } else {
+    // Wrap the attribute in commas, so that we can do an exact match.
+    nsAutoCString findAttribute(",");
+    findAttribute.Append(aAttribute);
+    findAttribute.Append(',');
+
+    // Check to see if the attribute is already stored. If it is, then also
+    // check to see if it is the last attribute in the string, or if the next
+    // character is a comma, this means we won't match substrings.
+    if (FindInReadable(findAttribute, mAttributes,
+                       nsCaseInsensitiveCStringComparator)) {
+      return NS_OK;
+    }
+
+    mAttributes.Append(Substring(findAttribute, 1));
+  }
+
+  // Now get the current path
+  nsCString newPath;
+  GetPathInternal(newPath);
+
+  // and update the base url
+  return NS_MutateURI(mBaseURL).SetPathQueryRef(newPath).Finalize(mBaseURL);
+}
+
+NS_IMETHODIMP nsLDAPURL::RemoveAttribute(const nsACString& aAttribute) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  if (mAttributes.IsEmpty()) return NS_OK;
+
+  // We use comma as delimiter (even first attr has a leading comma).
+  nsAutoCString findAttribute(",");
+  findAttribute.Append(aAttribute);
+  findAttribute.Append(',');
+
+  if (!FindInReadable(findAttribute, mAttributes,
+                      nsCaseInsensitiveCStringComparator)) {
+    return NS_OK;
+  }
+  if (mAttributes.Equals(findAttribute, nsCaseInsensitiveCStringComparator)) {
+    mAttributes.Truncate();
+  } else {
+    mAttributes.ReplaceSubstring(findAttribute, ","_ns);
+  }
+
+  // Now get the current path
+  nsCString newPath;
+  GetPathInternal(newPath);
+
+  // and update the base url
+  return NS_MutateURI(mBaseURL).SetPathQueryRef(newPath).Finalize(mBaseURL);
+}
+
+NS_IMETHODIMP nsLDAPURL::HasAttribute(const nsACString& aAttribute,
+                                      bool* _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+
+  // We use comma as delimiter (even first attr has a leading comma).
+  nsAutoCString findAttribute(",");
+  findAttribute.Append(aAttribute);
+  findAttribute.Append(',');
+
+  *_retval = FindInReadable(findAttribute, mAttributes,
+                            nsCaseInsensitiveCStringComparator);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLDAPURL::GetScope(int32_t* _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = mScope;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLDAPURL::SetScope(int32_t aScope) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  // Only allow scopes supported by the C-SDK
+  if ((aScope != SCOPE_BASE) && (aScope != SCOPE_ONELEVEL) &&
+      (aScope != SCOPE_SUBTREE))
+    return NS_ERROR_MALFORMED_URI;
+
+  mScope = aScope;
+
+  // Now get the current path
+  nsCString newPath;
+  GetPathInternal(newPath);
+
+  // and update the base url
+  return NS_MutateURI(mBaseURL).SetPathQueryRef(newPath).Finalize(mBaseURL);
+}
+
+NS_IMETHODIMP nsLDAPURL::GetFilter(nsACString& _retval) {
+  _retval.Assign(mFilter);
+  return NS_OK;
+}
+NS_IMETHODIMP nsLDAPURL::SetFilter(const nsACString& aFilter) {
+  if (!mBaseURL) return NS_ERROR_NOT_INITIALIZED;
+
+  mFilter.Assign(aFilter);
+
+  if (mFilter.IsEmpty()) mFilter.AssignLiteral("(objectclass=*)");
+
+  // Now get the current path
+  nsCString newPath;
+  GetPathInternal(newPath);
+
+  // and update the base url
+  return NS_MutateURI(mBaseURL).SetPathQueryRef(newPath).Finalize(mBaseURL);
+}
+
+NS_IMETHODIMP nsLDAPURL::GetOptions(uint32_t* _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = mOptions;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLDAPURL::SetOptions(uint32_t aOptions) {
+  // Secure is the only option supported at the moment
+  if ((mOptions & OPT_SECURE) == (aOptions & OPT_SECURE)) return NS_OK;
+
+  mOptions = aOptions;
+
+  if ((aOptions & OPT_SECURE) == OPT_SECURE) return SetScheme(LDAP_SSL_SCHEME);
+
+  return SetScheme(LDAP_SCHEME);
+}
+
+nsresult nsLDAPURL::SetRef(const nsACString& aRef) {
+  return NS_MutateURI(mBaseURL).SetRef(aRef).Finalize(mBaseURL);
+}
+
+NS_IMETHODIMP
+nsLDAPURL::GetRef(nsACString& result) { return mBaseURL->GetRef(result); }
+
+NS_IMETHODIMP nsLDAPURL::EqualsExceptRef(nsIURI* other, bool* result) {
+  return mBaseURL->EqualsExceptRef(other, result);
+}
+
+NS_IMETHODIMP
+nsLDAPURL::GetSpecIgnoringRef(nsACString& result) {
+  return mBaseURL->GetSpecIgnoringRef(result);
+}
+
+NS_IMETHODIMP
+nsLDAPURL::GetDisplaySpec(nsACString& aUnicodeSpec) {
+  return mBaseURL->GetDisplaySpec(aUnicodeSpec);
+}
+
+NS_IMETHODIMP
+nsLDAPURL::GetDisplayHostPort(nsACString& aUnicodeHostPort) {
+  return mBaseURL->GetDisplayHostPort(aUnicodeHostPort);
+}
+
+NS_IMETHODIMP
+nsLDAPURL::GetDisplayHost(nsACString& aUnicodeHost) {
+  return mBaseURL->GetDisplayHost(aUnicodeHost);
+}
+
+NS_IMETHODIMP
+nsLDAPURL::GetDisplayPrePath(nsACString& aPrePath) {
+  return mBaseURL->GetDisplayPrePath(aPrePath);
+}
+
+NS_IMETHODIMP
+nsLDAPURL::GetHasRef(bool* result) { return mBaseURL->GetHasRef(result); }
+
+NS_IMETHODIMP
+nsLDAPURL::GetFilePath(nsACString& aFilePath) {
+  return mBaseURL->GetFilePath(aFilePath);
+}
+
+nsresult nsLDAPURL::SetFilePath(const nsACString& aFilePath) {
+  return NS_MutateURI(mBaseURL).SetFilePath(aFilePath).Finalize(mBaseURL);
+}
+
+NS_IMETHODIMP
+nsLDAPURL::GetQuery(nsACString& aQuery) { return mBaseURL->GetQuery(aQuery); }
+
+nsresult nsLDAPURL::SetQuery(const nsACString& aQuery) {
+  return NS_MutateURI(mBaseURL).SetQuery(aQuery).Finalize(mBaseURL);
+}
+
+nsresult nsLDAPURL::SetQueryWithEncoding(const nsACString& aQuery,
+                                         const mozilla::Encoding* aEncoding) {
+  return NS_MutateURI(mBaseURL)
+      .SetQueryWithEncoding(aQuery, aEncoding)
+      .Finalize(mBaseURL);
+}
+
+NS_IMETHODIMP_(void)
+nsLDAPURL::Serialize(mozilla::ipc::URIParams& aParams) {
+  mBaseURL->Serialize(aParams);
+}
+
+NS_IMPL_ISUPPORTS(nsLDAPURL::Mutator, nsIURISetters, nsIURIMutator)
+
+NS_IMETHODIMP
+nsLDAPURL::Mutate(nsIURIMutator** aMutator) {
+  RefPtr<nsLDAPURL::Mutator> mutator = new nsLDAPURL::Mutator();
+  nsresult rv = mutator->InitFromURI(this);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+  mutator.forget(aMutator);
+  return NS_OK;
+}