Issue #1258 - Part 1: Import mailnews, ldap, and mork from comm-esr52.9.1

1 files changed, 610 insertions, 0 deletions

diff --git a/mailnews/addrbook/src/nsAbLDAPDirectoryQuery.cpp b/mailnews/addrbook/src/nsAbLDAPDirectoryQuery.cpp
new file mode 100644
index 000000000..9b22c796c
--- /dev/null
+++ b/mailnews/addrbook/src/nsAbLDAPDirectoryQuery.cpp
@@ -0,0 +1,610 @@
+/* -*- 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 "nsAbLDAPDirectoryQuery.h"
+#include "nsAbBoolExprToLDAPFilter.h"
+#include "nsILDAPMessage.h"
+#include "nsILDAPErrors.h"
+#include "nsILDAPOperation.h"
+#include "nsIAbLDAPAttributeMap.h"
+#include "nsIAbLDAPCard.h"
+#include "nsAbUtils.h"
+#include "nsAbBaseCID.h"
+#include "nsStringGlue.h"
+#include "prprf.h"
+#include "nsServiceManagerUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsCategoryManagerUtils.h"
+#include "nsAbLDAPDirectory.h"
+#include "nsAbLDAPListenerBase.h"
+#include "nsXPCOMCIDInternal.h"
+
+using namespace mozilla;
+
+// nsAbLDAPListenerBase inherits nsILDAPMessageListener
+class nsAbQueryLDAPMessageListener : public nsAbLDAPListenerBase
+{
+public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+
+  // Note that the directoryUrl is the details of the ldap directory
+  // without any search params or return attributes specified. The searchUrl
+  // therefore has the search params and return attributes specified.
+  //  nsAbQueryLDAPMessageListener(nsIAbDirectoryQuery* directoryQuery,
+  nsAbQueryLDAPMessageListener(nsIAbDirectoryQueryResultListener* resultListener,
+                               nsILDAPURL* directoryUrl,
+                               nsILDAPURL* searchUrl,
+                               nsILDAPConnection* connection,
+                               nsIAbDirectoryQueryArguments* queryArguments,
+                               nsIMutableArray* serverSearchControls,
+                               nsIMutableArray* clientSearchControls,
+                               const nsACString &login,
+                               const nsACString &mechanism,
+                               const int32_t resultLimit = -1,
+                               const int32_t timeOut = 0);
+
+  // nsILDAPMessageListener
+  NS_IMETHOD OnLDAPMessage(nsILDAPMessage *aMessage) override;
+
+protected:
+  virtual ~nsAbQueryLDAPMessageListener ();
+  nsresult OnLDAPMessageSearchEntry(nsILDAPMessage *aMessage);
+  nsresult OnLDAPMessageSearchResult(nsILDAPMessage *aMessage);
+
+  friend class nsAbLDAPDirectoryQuery;
+
+  nsresult Cancel();
+  virtual nsresult DoTask() override;
+  virtual void InitFailed(bool aCancelled = false) override;
+
+  nsCOMPtr<nsILDAPURL> mSearchUrl;
+  nsIAbDirectoryQueryResultListener *mResultListener;
+  int32_t mContextID;
+  nsCOMPtr<nsIAbDirectoryQueryArguments> mQueryArguments;
+  int32_t mResultLimit;
+
+  bool mFinished;
+  bool mCanceled;
+  bool mWaitingForPrevQueryToFinish;
+
+  nsCOMPtr<nsIMutableArray> mServerSearchControls;
+  nsCOMPtr<nsIMutableArray> mClientSearchControls;
+};
+
+
+NS_IMPL_ISUPPORTS(nsAbQueryLDAPMessageListener, nsILDAPMessageListener)
+
+nsAbQueryLDAPMessageListener::nsAbQueryLDAPMessageListener(
+        nsIAbDirectoryQueryResultListener *resultListener,
+        nsILDAPURL* directoryUrl,
+        nsILDAPURL* searchUrl,
+        nsILDAPConnection* connection,
+        nsIAbDirectoryQueryArguments* queryArguments,
+        nsIMutableArray* serverSearchControls,
+        nsIMutableArray* clientSearchControls,
+        const nsACString &login,
+        const nsACString &mechanism,
+        const int32_t resultLimit,
+        const int32_t timeOut) :
+  nsAbLDAPListenerBase(directoryUrl, connection, login, timeOut),
+  mSearchUrl(searchUrl),
+  mResultListener(resultListener),
+  mQueryArguments(queryArguments),
+  mResultLimit(resultLimit),
+  mFinished(false),
+  mCanceled(false),
+  mWaitingForPrevQueryToFinish(false),
+  mServerSearchControls(serverSearchControls),
+  mClientSearchControls(clientSearchControls)
+{
+  mSaslMechanism.Assign(mechanism);
+}
+
+nsAbQueryLDAPMessageListener::~nsAbQueryLDAPMessageListener ()
+{
+}
+
+nsresult nsAbQueryLDAPMessageListener::Cancel ()
+{
+    nsresult rv = Initiate();
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    MutexAutoLock lock(mLock);
+
+    if (mFinished || mCanceled)
+        return NS_OK;
+
+    mCanceled = true;
+    if (!mFinished)
+      mWaitingForPrevQueryToFinish = true;
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsAbQueryLDAPMessageListener::OnLDAPMessage(nsILDAPMessage *aMessage)
+{
+  nsresult rv = Initiate();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t messageType;
+  rv = aMessage->GetType(&messageType);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool cancelOperation = false;
+
+  // Enter lock
+  {
+    MutexAutoLock lock (mLock);
+
+    if (mFinished)
+      return NS_OK;
+
+    if (messageType == nsILDAPMessage::RES_SEARCH_RESULT)
+      mFinished = true;
+    else if (mCanceled)
+    {
+      mFinished = true;
+      cancelOperation = true;
+    }
+  }
+  // Leave lock
+
+  if (!mResultListener)
+    return NS_ERROR_NULL_POINTER;
+
+  if (!cancelOperation)
+  {
+    switch (messageType)
+    {
+    case nsILDAPMessage::RES_BIND:
+      rv = OnLDAPMessageBind(aMessage);
+      if (NS_FAILED(rv)) 
+        // We know the bind failed and hence the message has an error, so we
+        // can just call SearchResult with the message and that'll sort it out
+        // for us.
+        rv = OnLDAPMessageSearchResult(aMessage);
+      break;
+    case nsILDAPMessage::RES_SEARCH_ENTRY:
+      if (!mFinished && !mWaitingForPrevQueryToFinish)
+        rv = OnLDAPMessageSearchEntry(aMessage);
+      break;
+    case nsILDAPMessage::RES_SEARCH_RESULT:
+      mWaitingForPrevQueryToFinish = false;
+      rv = OnLDAPMessageSearchResult(aMessage);
+      NS_ENSURE_SUCCESS(rv, rv);
+      break;
+    default:
+      break;
+    }
+  }
+  else
+  {
+    if (mOperation)
+      rv = mOperation->AbandonExt();
+
+    rv = mResultListener->OnQueryResult(
+      nsIAbDirectoryQueryResultListener::queryResultStopped, 0);
+
+    // reset because we might re-use this listener...except don't do this
+    // until the search is done, so we'll ignore results from a previous
+    // search.
+    if (messageType == nsILDAPMessage::RES_SEARCH_RESULT)
+      mCanceled = mFinished = false;
+  }
+
+  return rv;
+}
+
+nsresult nsAbQueryLDAPMessageListener::DoTask()
+{
+  nsresult rv;
+  mCanceled = mFinished = false;
+
+  mOperation = do_CreateInstance(NS_LDAPOPERATION_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mOperation->Init(mConnection, this, nullptr);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString dn;
+  rv = mSearchUrl->GetDn(dn);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t scope;
+  rv = mSearchUrl->GetScope(&scope);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString filter;
+  rv = mSearchUrl->GetFilter(filter);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString attributes;
+  rv = mSearchUrl->GetAttributes(attributes);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mOperation->SetServerControls(mServerSearchControls);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mOperation->SetClientControls(mClientSearchControls);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return mOperation->SearchExt(dn, scope, filter, attributes, mTimeOut,
+                               mResultLimit);
+}
+
+void nsAbQueryLDAPMessageListener::InitFailed(bool aCancelled)
+{
+  if (!mResultListener)
+    return;
+
+  // In the !aCancelled case we know there was an error, but we won't be
+  // able to translate it, so just return an error code of zero.
+  mResultListener->OnQueryResult(
+      aCancelled ? nsIAbDirectoryQueryResultListener::queryResultStopped :
+                   nsIAbDirectoryQueryResultListener::queryResultError, 0);
+}
+
+nsresult nsAbQueryLDAPMessageListener::OnLDAPMessageSearchEntry(nsILDAPMessage *aMessage)
+{
+  nsresult rv;
+
+  if (!mResultListener)
+    return NS_ERROR_NULL_POINTER;
+
+  // the map for translating between LDAP attrs <-> addrbook fields
+  nsCOMPtr<nsISupports> iSupportsMap;
+  rv = mQueryArguments->GetTypeSpecificArg(getter_AddRefs(iSupportsMap));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIAbLDAPAttributeMap> map = do_QueryInterface(iSupportsMap, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIAbCard> card = do_CreateInstance(NS_ABLDAPCARD_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = map->SetCardPropertiesFromLDAPMessage(aMessage, card);
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  nsCOMPtr<nsIAbLDAPCard> ldapCard = do_QueryInterface(card, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = ldapCard->SetMetaProperties(aMessage);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return mResultListener->OnQueryFoundCard(card);
+}
+
+nsresult nsAbQueryLDAPMessageListener::OnLDAPMessageSearchResult(nsILDAPMessage *aMessage)
+{
+  int32_t errorCode;
+  nsresult rv = aMessage->GetErrorCode(&errorCode);
+  NS_ENSURE_SUCCESS(rv, rv);
+    
+  if (errorCode == nsILDAPErrors::SUCCESS || errorCode == nsILDAPErrors::SIZELIMIT_EXCEEDED)
+    return mResultListener->OnQueryResult(
+      nsIAbDirectoryQueryResultListener::queryResultComplete, 0);
+
+  return mResultListener->OnQueryResult(
+      nsIAbDirectoryQueryResultListener::queryResultError, errorCode);
+}
+
+// nsAbLDAPDirectoryQuery
+
+NS_IMPL_ISUPPORTS(nsAbLDAPDirectoryQuery, nsIAbDirectoryQuery,
+                              nsIAbDirectoryQueryResultListener)
+
+nsAbLDAPDirectoryQuery::nsAbLDAPDirectoryQuery() :
+    mInitialized(false)
+{
+}
+
+nsAbLDAPDirectoryQuery::~nsAbLDAPDirectoryQuery()
+{
+}
+
+NS_IMETHODIMP nsAbLDAPDirectoryQuery::DoQuery(nsIAbDirectory *aDirectory,
+  nsIAbDirectoryQueryArguments* aArguments,
+  nsIAbDirSearchListener* aListener,
+  int32_t aResultLimit,
+  int32_t aTimeOut,
+  int32_t* _retval)
+{
+  NS_ENSURE_ARG_POINTER(aListener);
+  NS_ENSURE_ARG_POINTER(aArguments);
+
+  mListeners.AppendObject(aListener);
+
+  // Ensure existing query is stopped. Context id doesn't matter here
+  nsresult rv = StopQuery(0);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mInitialized = true;
+
+  // Get the current directory as LDAP specific
+  nsCOMPtr<nsIAbLDAPDirectory> directory(do_QueryInterface(aDirectory, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  // We also need the current URL to check as well...
+  nsCOMPtr<nsILDAPURL> currentUrl;
+  rv = directory->GetLDAPURL(getter_AddRefs(currentUrl));
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  nsAutoCString login;
+  rv = directory->GetAuthDn(login);
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  nsAutoCString saslMechanism;
+  rv = directory->GetSaslMechanism(saslMechanism);
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  uint32_t protocolVersion;
+  rv = directory->GetProtocolVersion(&protocolVersion);
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  // To do:
+  // Ensure query is stopped
+  // If connection params have changed re-create connection
+  // else reuse existing connection
+  
+  bool redoConnection = false;
+  
+  if (!mConnection || !mDirectoryUrl)
+  {
+    mDirectoryUrl = currentUrl;
+    aDirectory->GetUuid(mDirectoryId);
+    mCurrentLogin = login;
+    mCurrentMechanism = saslMechanism;
+    mCurrentProtocolVersion = protocolVersion;
+    redoConnection = true;
+  }
+  else
+  {
+    bool equal;
+    rv = mDirectoryUrl->Equals(currentUrl, &equal);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (!equal)
+    {
+      mDirectoryUrl = currentUrl;
+      aDirectory->GetUuid(mDirectoryId);
+      mCurrentLogin = login;
+      mCurrentMechanism = saslMechanism;
+      mCurrentProtocolVersion = protocolVersion;
+      redoConnection = true;
+    }
+    else
+    {
+      // Has login or version changed?
+      if (login != mCurrentLogin ||
+          saslMechanism != mCurrentMechanism ||
+          protocolVersion != mCurrentProtocolVersion)
+      {
+        redoConnection = true;
+        mCurrentLogin = login;
+        mCurrentMechanism = saslMechanism;
+        mCurrentProtocolVersion = protocolVersion;
+      }
+    }
+  }
+
+  nsCOMPtr<nsIURI> uri;
+  rv = mDirectoryUrl->Clone(getter_AddRefs(uri));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsILDAPURL> url(do_QueryInterface(uri, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Get/Set the return attributes
+  nsCOMPtr<nsISupports> iSupportsMap;
+  rv = aArguments->GetTypeSpecificArg(getter_AddRefs(iSupportsMap));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIAbLDAPAttributeMap> map = do_QueryInterface(iSupportsMap, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Require all attributes that are mapped to card properties
+  nsAutoCString returnAttributes;
+  rv = map->GetAllCardAttributes(returnAttributes);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = url->SetAttributes(returnAttributes);
+  // Now do the error check
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Also require the objectClass attribute, it is used by
+  // nsAbLDAPCard::SetMetaProperties
+  rv = url->AddAttribute(NS_LITERAL_CSTRING("objectClass"));
+
+  nsAutoCString filter;
+
+  // Get filter from arguments if set:
+  rv = aArguments->GetFilter(filter);
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  if (filter.IsEmpty()) {
+    // Get the filter
+    nsCOMPtr<nsISupports> supportsExpression;
+    rv = aArguments->GetExpression(getter_AddRefs(supportsExpression));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIAbBooleanExpression> expression(do_QueryInterface(supportsExpression, &rv));
+
+    // figure out how we map attribute names to addressbook fields for this
+    // query
+    rv = nsAbBoolExprToLDAPFilter::Convert(map, expression, filter);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  /*
+   * Mozilla itself cannot arrive here with a blank filter
+   * as the nsAbLDAPDirectory::StartSearch() disallows it.
+   * But 3rd party LDAP query integration with Mozilla begins 
+   * in this method.
+   *
+   * Default the filter string if blank, otherwise it gets
+   * set to (objectclass=*) which returns everything. Set 
+   * the default to (objectclass=inetorgperson) as this 
+   * is the most appropriate default objectclass which is 
+   * central to the makeup of the mozilla ldap address book 
+   * entries.
+   */
+  if (filter.IsEmpty())
+  {
+    filter.AssignLiteral("(objectclass=inetorgperson)");
+  }
+
+  // get the directoryFilter from the directory url and merge it with the user's
+  // search filter
+  nsAutoCString urlFilter;
+  rv = mDirectoryUrl->GetFilter(urlFilter);
+  
+  // if urlFilter is unset (or set to the default "objectclass=*"), there's
+  // no need to AND in an empty search term, so leave prefix and suffix empty
+  
+  nsAutoCString searchFilter;
+  if (urlFilter.Length() && !urlFilter.EqualsLiteral("(objectclass=*)"))
+  {
+    // if urlFilter isn't parenthesized, we need to add in parens so that
+    // the filter works as a term to &
+    //
+    if (urlFilter[0] != '(')
+    {
+      searchFilter = NS_LITERAL_CSTRING("(&(");
+      searchFilter.Append(urlFilter);
+      searchFilter.AppendLiteral(")");
+    }
+    else
+    {
+      searchFilter = NS_LITERAL_CSTRING("(&");
+      searchFilter.Append(urlFilter);
+    }
+  
+    searchFilter += filter;
+    searchFilter += ')';
+  } 
+  else
+    searchFilter = filter;
+
+  rv = url->SetFilter(searchFilter);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Now formulate the search string
+  
+  // Get the scope
+  int32_t scope;
+  bool doSubDirectories;
+  rv = aArguments->GetQuerySubDirectories (&doSubDirectories);
+  NS_ENSURE_SUCCESS(rv, rv);
+  scope = doSubDirectories ? nsILDAPURL::SCOPE_SUBTREE :
+                             nsILDAPURL::SCOPE_ONELEVEL;
+
+  rv = url->SetScope(scope);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // too soon? Do we need a new listener?
+  // If we already have a connection, and don't need to re-do it, give it the
+  // new search details and go for it...
+  if (!redoConnection)
+  {
+    nsAbQueryLDAPMessageListener *msgListener = 
+      static_cast<nsAbQueryLDAPMessageListener *>(static_cast<nsILDAPMessageListener *>(mListener.get()));
+    if (msgListener)
+    {
+      // Ensure the urls are correct
+      msgListener->mDirectoryUrl = mDirectoryUrl;
+      msgListener->mSearchUrl = url;
+      // Also ensure we set the correct result limit
+      msgListener->mResultLimit = aResultLimit;
+      return msgListener->DoTask();
+    }
+  }
+  
+  nsCOMPtr<nsIAbLDAPDirectory> abLDAPDir = do_QueryInterface(aDirectory, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMutableArray> serverSearchControls;
+  rv = abLDAPDir->GetSearchServerControls(getter_AddRefs(serverSearchControls));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMutableArray> clientSearchControls;
+  rv = abLDAPDir->GetSearchClientControls(getter_AddRefs(clientSearchControls));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Create the new connection (which cause the old one to be dropped if necessary)
+  mConnection = do_CreateInstance(NS_LDAPCONNECTION_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIAbDirectoryQueryResultListener> resultListener =
+    do_QueryInterface((nsIAbDirectoryQuery*)this, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Initiate LDAP message listener
+  nsAbQueryLDAPMessageListener* _messageListener =
+    new nsAbQueryLDAPMessageListener(resultListener, mDirectoryUrl, url,
+                                     mConnection, aArguments,
+                                     serverSearchControls, clientSearchControls,
+                                     mCurrentLogin, mCurrentMechanism,
+                                     aResultLimit, aTimeOut);
+  if (_messageListener == NULL)
+    return NS_ERROR_OUT_OF_MEMORY;
+  
+  mListener = _messageListener;
+  *_retval = 1;
+
+  // Now lets initialize the LDAP connection properly. We'll kick
+  // off the bind operation in the callback function, |OnLDAPInit()|.
+  rv = mConnection->Init(mDirectoryUrl, mCurrentLogin,
+                         mListener, nullptr, mCurrentProtocolVersion);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return rv;
+}
+
+/* void stopQuery (in long contextID); */
+NS_IMETHODIMP nsAbLDAPDirectoryQuery::StopQuery(int32_t contextID)
+{
+  mInitialized = true;
+
+  if (!mListener)
+    return NS_OK;
+
+  nsAbQueryLDAPMessageListener *listener = 
+    static_cast<nsAbQueryLDAPMessageListener *>(static_cast<nsILDAPMessageListener *>(mListener.get()));
+  if (listener)
+    return listener->Cancel();
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAbLDAPDirectoryQuery::OnQueryFoundCard(nsIAbCard *aCard)
+{
+  aCard->SetDirectoryId(mDirectoryId);
+
+  for (int32_t i = 0; i < mListeners.Count(); ++i)
+    mListeners[i]->OnSearchFoundCard(aCard);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAbLDAPDirectoryQuery::OnQueryResult(int32_t aResult,
+                                                    int32_t aErrorCode)
+{
+  uint32_t count = mListeners.Count();
+
+  // XXX: Temporary fix for crasher needs reviewing as part of bug 135231.
+  // Temporarily add a reference to ourselves, in case the only thing
+  // keeping us alive is the link with the listener.
+  NS_ADDREF_THIS();
+
+  for (int32_t i = count - 1; i >= 0; --i)
+  {
+    mListeners[i]->OnSearchFinished(aResult, EmptyString());
+    mListeners.RemoveObjectAt(i);
+  }
+
+  NS_RELEASE_THIS();
+
+  return NS_OK;
+}