put this here

git-svn-id: svn://10.0.0.236/branches/alecf_fastfolder_branch@51617 18797224-902f-48f8-a5cc-f745e15eee43

mozilla/mailnews/base/src/nsMsgMailSession.cpp

@@ -0,0 +1,298 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "msgCore.h" // for pre-compiled headers
+//#include "nsIMsgIdentity.h"
+#include "nsIMsgAccountManager.h"
+//#include "nsIPop3IncomingServer.h"
+#include "nsMsgMailSession.h"
+#include "nsMsgLocalCID.h"
+#include "nsMsgBaseCID.h"
+#include "nsCOMPtr.h"
+#include "nsMsgFolderCache.h"
+#include "nsIFileLocator.h"
+#include "nsFileLocations.h"
+#include "nsIMsgStatusFeedback.h"
+
+NS_IMPL_ISUPPORTS(nsMsgMailSession, nsCOMTypeInfo<nsIMsgMailSession>::GetIID());
+
+static NS_DEFINE_CID(kMsgAccountManagerCID, NS_MSGACCOUNTMANAGER_CID);
+static NS_DEFINE_CID(kMsgFolderCacheCID, NS_MSGFOLDERCACHE_CID);
+static NS_DEFINE_IID(kIFileLocatorIID,      NS_IFILELOCATOR_IID);
+static NS_DEFINE_CID(kFileLocatorCID,       NS_FILELOCATOR_CID);
+ 
+//static NS_DEFINE_CID(kMsgIdentityCID, NS_MSGIDENTITY_CID);
+//static NS_DEFINE_CID(kPop3IncomingServerCID, NS_POP3INCOMINGSERVER_CID);
+//static NS_DEFINE_CID(kPrefCID, NS_PREF_CID);
+    
+
+nsMsgMailSession::nsMsgMailSession():
+  mRefCnt(0),
+  m_accountManager(0),
+  m_msgFolderCache(0)
+{
+
+	NS_INIT_REFCNT();
+}
+
+
+nsMsgMailSession::~nsMsgMailSession()
+{
+	Shutdown();
+}
+
+nsresult nsMsgMailSession::Init()
+{
+	nsresult rv = NS_NewISupportsArray(getter_AddRefs(mListeners));
+
+	return rv;
+
+}
+
+nsresult nsMsgMailSession::Shutdown()
+{
+  if(m_accountManager)
+  {
+	  if (m_msgFolderCache)
+		m_accountManager->WriteToFolderCache(m_msgFolderCache);
+	  m_accountManager->CloseCachedConnections();
+	  m_accountManager->UnloadAccounts();
+  }
+
+  NS_IF_RELEASE(m_accountManager);
+
+  NS_IF_RELEASE(m_msgFolderCache);
+
+  return NS_OK;
+}
+
+// nsIMsgMailSession
+nsresult nsMsgMailSession::GetCurrentIdentity(nsIMsgIdentity ** aIdentity)
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgAccountManager> accountManager;
+  rv = GetAccountManager(getter_AddRefs(accountManager));
+  if (NS_FAILED(rv)) return rv;
+
+  nsCOMPtr<nsIMsgAccount> defaultAccount;
+  rv = accountManager->GetDefaultAccount(getter_AddRefs(defaultAccount));
+  if (NS_FAILED(rv)) return rv;
+  
+  rv = defaultAccount->GetDefaultIdentity(aIdentity);
+  if (NS_SUCCEEDED(rv))
+  	NS_ADDREF(*aIdentity);
+  
+  return rv;
+}
+
+nsresult nsMsgMailSession::GetCurrentServer(nsIMsgIncomingServer ** aServer)
+{
+  nsresult rv=NS_ERROR_UNEXPECTED;
+
+  nsCOMPtr<nsIMsgAccountManager> accountManager;
+  rv = GetAccountManager(getter_AddRefs(accountManager));
+  if (NS_FAILED(rv)) return rv;
+  
+  nsCOMPtr<nsIMsgAccount> defaultAccount;
+  rv = accountManager->GetDefaultAccount(getter_AddRefs(defaultAccount));
+  if (NS_FAILED(rv)) return rv;
+
+  //if successful aServer will be addref'd by GetIncomingServer
+  rv = defaultAccount->GetIncomingServer(aServer);
+
+  return rv;
+}
+
+nsresult nsMsgMailSession::GetAccountManager(nsIMsgAccountManager* *aAM)
+{
+  NS_ENSURE_ARG_POINTER(aAM);
+
+  nsresult rv;
+  
+  NS_WITH_SERVICE(nsIMsgAccountManager, accountManager, kMsgAccountManagerCID, &rv);
+  if (NS_FAILED(rv)) return rv;
+  accountManager->LoadAccounts();
+    
+  *aAM = accountManager;
+  NS_IF_ADDREF(*aAM);
+  return NS_OK;
+}
+
+nsresult nsMsgMailSession::GetFolderCache(nsIMsgFolderCache* *aFolderCache)
+{
+  if (!aFolderCache) return NS_ERROR_NULL_POINTER;
+
+  nsresult rv = NS_OK;
+
+  if (!m_msgFolderCache)
+  {
+    rv = nsComponentManager::CreateInstance(kMsgFolderCacheCID,
+                                            NULL,
+                                            nsCOMTypeInfo<nsIMsgFolderCache>::GetIID(),
+                                            (void **)&m_msgFolderCache);
+    if (NS_FAILED(rv))
+		return rv;
+
+    nsCOMPtr <nsIFileSpec> cacheFile;
+    NS_WITH_SERVICE(nsIFileLocator, locator, kFileLocatorCID, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    rv = locator->GetFileLocation(nsSpecialFileSpec::App_MessengerFolderCache50, getter_AddRefs(cacheFile));
+    if (NS_FAILED(rv)) return rv;
+
+    m_msgFolderCache->Init(cacheFile);
+
+  }
+
+  *aFolderCache = m_msgFolderCache;
+  NS_IF_ADDREF(*aFolderCache);
+  return rv;
+}
+
+nsresult nsMsgMailSession::GetTemporaryMsgStatusFeedback(nsIMsgStatusFeedback* *aMsgStatusFeedback)
+{
+  if (!aMsgStatusFeedback) return NS_ERROR_NULL_POINTER;
+  
+  *aMsgStatusFeedback = m_temporaryMsgStatusFeedback;
+  NS_IF_ADDREF(*aMsgStatusFeedback);
+  return NS_OK;
+}
+
+
+nsresult nsMsgMailSession::SetTemporaryMsgStatusFeedback(nsIMsgStatusFeedback* aMsgStatusFeedback)
+{
+  m_temporaryMsgStatusFeedback = do_QueryInterface(aMsgStatusFeedback);
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP nsMsgMailSession::AddFolderListener(nsIFolderListener * listener)
+{
+  mListeners->AppendElement(listener);
+  return NS_OK;
+
+}
+
+NS_IMETHODIMP nsMsgMailSession::RemoveFolderListener(nsIFolderListener * listener)
+{
+  mListeners->RemoveElement(listener);
+  return NS_OK;
+
+}
+
+NS_IMETHODIMP
+nsMsgMailSession::NotifyFolderItemPropertyChanged(nsISupports *item,
+                                                  const char *property,
+                                                  const char* oldValue,
+                                                  const char* newValue)
+{
+	nsresult rv;
+	PRUint32 count;
+	rv = mListeners->Count(&count);
+	if (NS_FAILED(rv)) return rv;
+
+	
+	for(PRUint32 i = 0; i < count; i++)
+	{
+		nsCOMPtr<nsIFolderListener> listener = getter_AddRefs((nsIFolderListener*)mListeners->ElementAt(i));
+		listener->OnItemPropertyChanged(item, property, oldValue, newValue);
+	}
+
+	return NS_OK;
+
+}
+
+NS_IMETHODIMP
+nsMsgMailSession::NotifyFolderItemPropertyFlagChanged(nsISupports *item,
+                                                      const char *property,
+                                                      PRUint32 oldValue,
+                                                      PRUint32 newValue)
+{
+	nsresult rv;
+	PRUint32 count;
+	rv = mListeners->Count(&count);
+	if (NS_FAILED(rv)) return rv;
+
+	
+	for(PRUint32 i = 0; i < count; i++)
+	{
+		nsCOMPtr<nsIFolderListener> listener = getter_AddRefs((nsIFolderListener*)mListeners->ElementAt(i));
+		listener->OnItemPropertyFlagChanged(item, property, oldValue, newValue);
+	}
+
+	return NS_OK;
+
+}
+
+NS_IMETHODIMP nsMsgMailSession::NotifyFolderItemAdded(nsIFolder *folder, nsISupports *item)
+{
+	nsresult rv;
+	PRUint32 count;
+	rv = mListeners->Count(&count);
+	if (NS_FAILED(rv)) return rv;
+
+	
+	for(PRUint32 i = 0; i < count; i++)
+	{
+		nsCOMPtr<nsIFolderListener> listener = getter_AddRefs((nsIFolderListener*)mListeners->ElementAt(i));
+		listener->OnItemAdded(folder, item);
+	}
+
+	return NS_OK;
+
+}
+
+NS_IMETHODIMP nsMsgMailSession::NotifyFolderItemDeleted(nsIFolder *folder, nsISupports *item)
+{
+	nsresult rv;
+	PRUint32 count;
+	rv = mListeners->Count(&count);
+	if (NS_FAILED(rv)) return rv;
+
+	
+	for(PRUint32 i = 0; i < count; i++)
+	{
+		nsCOMPtr<nsIFolderListener> listener = getter_AddRefs((nsIFolderListener*)mListeners->ElementAt(i));
+		listener->OnItemRemoved(folder, item);
+	}
+	return NS_OK;
+
+}
+
+NS_IMETHODIMP  nsMsgMailSession::NotifyFolderLoaded(nsIFolder *folder)
+{
+
+	nsresult rv;
+	PRUint32 count;
+	rv = mListeners->Count(&count);
+	if (NS_FAILED(rv)) return rv;
+
+	
+	for(PRUint32 i = 0; i < count; i++)
+	{
+		nsCOMPtr<nsIFolderListener> listener = getter_AddRefs((nsIFolderListener*)mListeners->ElementAt(i));
+		listener->OnFolderLoaded(folder);
+	}
+	return NS_OK;
+
+
+}
+
+
+

mozilla/mailnews/base/util/MANIFEST

@@ -0,0 +1,35 @@
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+#
+# This is a list of local files which get copied to the mozilla:dist:mailnews directory
+#
+
+nsMsgLineBuffer.h
+nsMsgGroupRecord.h
+nsUInt32Array.h
+nsMsgKeySet.h
+nsMsgFolder.h
+nsMsgDBFolder.h
+nsLocalFolderSummarySpec.h
+nsMsgIdentity.h
+nsMsgIncomingServer.h
+nsNewsSummarySpec.h
+nsMsgUtils.h
+nsMessage.h
+nsMsgProtocol.h
+nsMsgTxn.h
+nsMsgMailNewsUrl.h
+nsMsgI18N.h
+

mozilla/mailnews/base/util/Makefile.in

@@ -0,0 +1,75 @@
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+#
+
+DEPTH		= ../../..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE		= msgbaseutil
+LIBRARY_NAME	= msgbaseutil
+
+CPPSRCS		= \
+		nsMsgGroupRecord.cpp \
+		nsMsgLineBuffer.cpp \
+		nsMsgFolder.cpp \
+		nsMsgDBFolder.cpp \
+		nsUInt32Array.cpp \
+		nsMsgKeySet.cpp \
+		nsLocalFolderSummarySpec.cpp \
+		nsNewsSummarySpec.cpp \
+		nsMsgIdentity.cpp \
+		nsMsgIncomingServer.cpp \
+		nsMsgUtils.cpp \
+		nsMessage.cpp \
+		nsMsgProtocol.cpp \
+		nsMsgMailNewsUrl.cpp \
+		nsMsgTxn.cpp \
+		nsMsgI18N.cpp \
+		$(NULL)
+
+EXPORTS		= \
+		nsMsgGroupRecord.h \
+		nsMsgLineBuffer.h \
+		nsUInt32Array.h \
+		nsMsgKeySet.h \
+		nsMsgFolder.h \
+		nsMsgDBFolder.h \
+		nsLocalFolderSummarySpec.h \
+		nsNewsSummarySpec.h \
+		nsMsgIdentity.h \
+		nsMsgIncomingServer.h \
+		nsMsgUtils.h \
+		nsMessage.h \
+		nsMsgProtocol.h \
+		nsMsgMailNewsUrl.h \
+		nsMsgTxn.h \
+		nsMsgI18N.h \
+		$(NULL)
+
+EXTRA_DSO_LDOPTS = \
+	-L$(DIST)/bin \
+	-L$(DIST)/lib \
+	-lxpcom \
+	-lrdfutil_s \
+	$(NSPR_LIBS) \
+	$(NULL)
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/mailnews/base/util/macbuild/msgUtilPrefix.h

@@ -0,0 +1,21 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+
+
+#include "MacPrefix.h"

mozilla/mailnews/base/util/macbuild/msgUtilPrefixDebug.h

@@ -0,0 +1,21 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+
+
+#include "MacPrefix_debug.h"

mozilla/mailnews/base/util/makefile.win

@@ -0,0 +1,87 @@
+#!nmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+DEPTH=..\..\..
+MODULE= msgbsutl
+
+include <$(DEPTH)\config\config.mak>
+
+################################################################################
+## exports
+
+EXPORTS=                \
+	nsMsgLineBuffer.h	\
+	nsMsgGroupRecord.h  \
+	nsUInt32Array.h	\
+	nsMsgKeySet.h			\
+	nsMsgFolder.h			\
+	nsMsgDBFolder.h			\
+	nsLocalFolderSummarySpec.h	\
+	nsMsgIdentity.h			\
+	nsMsgIncomingServer.h	\
+	nsNewsSummarySpec.h \
+	nsMsgUtils.h \
+	nsMessage.h \
+	nsMsgProtocol.h \
+	nsMsgMailNewsUrl.h \
+	nsMsgTxn.h \
+	nsMsgI18N.h \
+	$(NULL)
+
+################################################################################
+## library
+
+LIBNAME = .\$(OBJDIR)\msgbsutl
+DLL = $(LIBNAME).dll
+
+DEFINES=-D_IMPL_NS_MSG_BASE
+
+LCFLAGS =		   \
+        $(LCFLAGS) \
+        $(DEFINES) \
+        $(NULL)
+
+CPP_OBJS=                               \
+	.\$(OBJDIR)\nsMsgGroupRecord.obj    \
+	.\$(OBJDIR)\nsMsgLineBuffer.obj     \
+	.\$(OBJDIR)\nsUInt32Array.obj		\
+	.\$(OBJDIR)\nsMsgKeySet.obj			\
+	.\$(OBJDIR)\nsMsgFolder.obj			\
+	.\$(OBJDIR)\nsMsgDBFolder.obj		\
+	.\$(OBJDIR)\nsLocalFolderSummarySpec.obj	\
+	.\$(OBJDIR)\nsMsgIdentity.obj		\
+	.\$(OBJDIR)\nsMsgIncomingServer.obj	\
+	.\$(OBJDIR)\nsNewsSummarySpec.obj	\
+	.\$(OBJDIR)\nsMsgUtils.obj			\
+	.\$(OBJDIR)\nsMessage.obj			\
+	.\$(OBJDIR)\nsMsgProtocol.obj		\
+	.\$(OBJDIR)\nsMsgMailNewsUrl.obj	\
+	.\$(OBJDIR)\nsMsgTxn.obj			\
+	.\$(OBJDIR)\nsMsgI18N.obj			\
+	$(NULL)
+
+LLIBS=								\
+	$(DIST)\lib\xpcom.lib			\
+	$(DIST)\lib\rdfutil_s.lib		\
+	$(LIBNSPR)						\
+	$(NULL)
+
+include <$(DEPTH)/config/rules.mak>
+
+libs:: $(DLL)
+	$(MAKE_INSTALL)  $(LIBNAME).$(DLL_SUFFIX) $(DIST)\bin
+	$(MAKE_INSTALL)  $(LIBNAME).$(LIB_SUFFIX) $(DIST)\lib

mozilla/mailnews/base/util/nsLocalFolderSummarySpec.cpp

@@ -0,0 +1,76 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "nsLocalFolderSummarySpec.h"
+#include "plstr.h"
+#include "nsString.h"
+
+MOZ_DECL_CTOR_COUNTER(nsLocalFolderSummarySpec);
+
+nsLocalFolderSummarySpec::~nsLocalFolderSummarySpec()
+{
+	MOZ_COUNT_DTOR(nsLocalFolderSummarySpec);
+
+}
+
+nsLocalFolderSummarySpec::nsLocalFolderSummarySpec()
+{
+	MOZ_COUNT_CTOR(nsLocalFolderSummarySpec);
+}
+
+nsLocalFolderSummarySpec::nsLocalFolderSummarySpec(const char *folderPath, PRBool create)
+  : nsFileSpec(folderPath, create)
+{
+	MOZ_COUNT_CTOR(nsLocalFolderSummarySpec);
+	CreateSummaryFileName();
+}
+
+nsLocalFolderSummarySpec::nsLocalFolderSummarySpec(const nsFileSpec& inFolderPath)
+: nsFileSpec(inFolderPath)
+{
+	MOZ_COUNT_CTOR(nsLocalFolderSummarySpec);
+	CreateSummaryFileName();
+}
+
+nsLocalFolderSummarySpec::nsLocalFolderSummarySpec(const nsFilePath &inFolderPath, PRBool create) : nsFileSpec(inFolderPath, create)
+{
+	MOZ_COUNT_CTOR(nsLocalFolderSummarySpec);
+	CreateSummaryFileName();
+}
+
+void nsLocalFolderSummarySpec::SetFolderName(const char *folderPath)
+{
+	*this = folderPath;
+}
+
+void nsLocalFolderSummarySpec::	CreateSummaryFileName()
+{
+	char *leafName = GetLeafName();
+
+	nsString fullLeafName(leafName);
+
+	// Append .msf (msg summary file) this is what windows will want.
+	// Mac and Unix can decide for themselves.
+
+	fullLeafName += ".msf";				// message summary file
+	char *cLeafName = fullLeafName.ToNewCString();
+	SetLeafName(cLeafName);
+    nsAllocator::Free(cLeafName);
+	PL_strfree(leafName);
+}
+

mozilla/mailnews/base/util/nsLocalFolderSummarySpec.h

@@ -0,0 +1,46 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _nsLocalFolderSummarySpec_H
+#define _nsLocalFolderSummarySpec_H
+
+#include "msgCore.h"
+#include "nsFileSpec.h"
+
+// Class to name a summary file for a local mail folder,
+// given a full folder file spec. For windows, this just means tacking .msf on the end.
+// For Unix, it might mean something like putting a '.' on the front and .msgsummary on the end.
+// Note this class expects the invoking code to fully specify the folder path. 
+// This class does NOT prepend the local folder directory, or put .sbd on the containing
+// directory names.
+class NS_MSG_BASE nsLocalFolderSummarySpec : public nsFileSpec
+{
+public:
+			virtual ~nsLocalFolderSummarySpec();
+			nsLocalFolderSummarySpec();
+			nsLocalFolderSummarySpec(const char *folderPath, PRBool create = PR_FALSE);
+			nsLocalFolderSummarySpec(const nsFileSpec& inFolderPath);
+			nsLocalFolderSummarySpec(const nsFilePath &inFolderPath, PRBool create = PR_FALSE);
+			void SetFolderName(const char *folderPath);
+
+protected:
+	void	CreateSummaryFileName();
+
+};
+
+#endif

mozilla/mailnews/base/util/nsMessage.cpp

@@ -0,0 +1,509 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "msgCore.h"    // precompiled header...
+#include "nsMessage.h"
+#include "nsIMsgFolder.h"
+
+
+nsMessage::nsMessage(void)
+  : nsRDFResource(), mFolder(nsnull)
+{
+
+}
+
+nsMessage::~nsMessage(void)
+{
+	//Member variables are either nsCOMPtr's or ptrs we don't want to own.
+}
+
+NS_IMPL_ADDREF_INHERITED(nsMessage, nsRDFResource)
+NS_IMPL_RELEASE_INHERITED(nsMessage, nsRDFResource)                        
+
+NS_IMETHODIMP nsMessage::QueryInterface(REFNSIID aIID, void** aInstancePtr)
+{
+	if (!aInstancePtr) return NS_ERROR_NULL_POINTER;
+	*aInstancePtr = nsnull;
+	if (aIID.Equals(nsCOMTypeInfo<nsIMessage>::GetIID()) || aIID.Equals(nsCOMTypeInfo<nsIDBMessage>::GetIID()))
+	{
+		*aInstancePtr = NS_STATIC_CAST(nsIDBMessage*, this);
+	}              
+	if(*aInstancePtr)
+	{
+		AddRef();
+		return NS_OK;
+	}
+
+	return nsRDFResource::QueryInterface(aIID, aInstancePtr);
+}
+
+NS_IMETHODIMP
+nsMessage::Init(const char* aURI)
+{
+
+	return nsRDFResource::Init(aURI);
+}
+
+
+NS_IMETHODIMP nsMessage::GetProperty(const char *propertyName, nsString &resultProperty)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetProperty(propertyName, resultProperty);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetProperty(const char *propertyName, nsString &propertyStr)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetProperty(propertyName, propertyStr);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetUint32Property(const char *propertyName, PRUint32 *pResult)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetUint32Property(propertyName, pResult);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetUint32Property(const char *propertyName, PRUint32 propertyVal)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetUint32Property(propertyName, propertyVal);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetNumReferences(PRUint16 *result)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetNumReferences(result);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetStringReference(PRInt32 refNum, nsCString &resultReference)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetStringReference(refNum, resultReference);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetDate(PRTime *result)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetDate(result);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetDate(PRTime date)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetDate(date);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetMessageId(const char *messageId)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetMessageId(messageId);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetReferences(const char *references)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetReferences(references);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetCCList(const char *ccList)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetCCList(ccList);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetRecipients(const char *recipients, PRBool recipientsIsNewsgroup)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetRecipients(recipients, recipientsIsNewsgroup);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetRecipientsArray(const char *names, const char *addresses, PRUint32 numAddresses)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetRecipientsArray(names, addresses, numAddresses);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetCCListArray(const char *names, const char *addresses, PRUint32 numAddresses)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetCCListArray(names, addresses, numAddresses);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetAuthor(const char *author)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetAuthor(author);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetSubject(const char *subject)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetSubject(subject);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetStatusOffset(PRUint32 statusOffset)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetStatusOffset(statusOffset);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+
+NS_IMETHODIMP nsMessage::GetAuthor(nsString *resultAuthor)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetAuthor(resultAuthor);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetSubject(nsString *resultSubject)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetSubject(resultSubject);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetRecipients(nsString *resultRecipients)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetRecipients(resultRecipients);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetCCList(nsString *ccList)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetCCList(ccList);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetMessageId(nsCString *resultMessageId)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetMessageId(resultMessageId);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+
+NS_IMETHODIMP nsMessage::GetMime2DecodedAuthor(nsString *resultAuthor)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetMime2DecodedAuthor(resultAuthor);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetMime2DecodedSubject(nsString *resultSubject)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetMime2DecodedSubject(resultSubject);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetMime2DecodedRecipients(nsString *resultRecipients)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetMime2DecodedRecipients(resultRecipients);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+
+NS_IMETHODIMP nsMessage::GetAuthorCollationKey(nsString *resultAuthor)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetAuthorCollationKey(resultAuthor);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetSubjectCollationKey(nsString *resultSubject)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetSubjectCollationKey(resultSubject);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetRecipientsCollationKey(nsString *resultRecipients)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetRecipientsCollationKey(resultRecipients);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+
+NS_IMETHODIMP nsMessage::GetFlags(PRUint32 *result)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetFlags(result);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetFlags(PRUint32 flags)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetFlags(flags);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::OrFlags(PRUint32 flags, PRUint32 *result)
+{
+	if(mMsgHdr)
+		return mMsgHdr->OrFlags(flags, result);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::AndFlags(PRUint32 flags, PRUint32 *result)
+{
+	if(mMsgHdr)
+		return mMsgHdr->AndFlags(flags, result);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::MarkRead(PRBool bRead)
+{
+	if(mMsgHdr)
+		return mMsgHdr->MarkRead(bRead);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::MarkFlagged(PRBool bFlagged)
+{
+	if(mMsgHdr)
+		return mMsgHdr->MarkFlagged(bFlagged);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetMessageKey(nsMsgKey *result)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetMessageKey(result);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetThreadId(nsMsgKey *result)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetThreadId(result);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetThreadId(nsMsgKey inKey)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetThreadId(inKey);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetMessageKey(nsMsgKey inKey)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetMessageKey(inKey);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetMessageSize(PRUint32 *result)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetMessageSize(result);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetLineCount(PRUint32 *result)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetLineCount(result);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetMessageSize(PRUint32 messageSize)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetMessageSize(messageSize);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetLineCount(PRUint32 lineCount)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetLineCount(lineCount);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetPriority(nsMsgPriority priority)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetPriority(priority);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetPriority(const char *priority)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetPriority(priority);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetPriority(nsMsgPriority *result)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetPriority(result);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+
+NS_IMETHODIMP nsMessage::GetMessageOffset(PRUint32 *result)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetMessageOffset(result);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetStatusOffset(PRUint32 *result)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetStatusOffset(result);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetCharSet(nsString *result)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetCharSet(result);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::GetThreadParent(nsMsgKey *result)
+{
+	if(mMsgHdr)
+		return mMsgHdr->GetThreadParent(result);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessage::SetThreadParent(nsMsgKey inKey)
+{
+	if(mMsgHdr)
+		return mMsgHdr->SetThreadParent(inKey);
+	else
+		return NS_ERROR_FAILURE;
+}
+
+
+NS_IMETHODIMP nsMessage::GetMsgFolder(nsIMsgFolder **folder)
+{
+	if(!folder)
+		return NS_ERROR_NULL_POINTER;
+	*folder = mFolder;
+	if(mFolder)
+	{
+		NS_ADDREF(mFolder);
+		return NS_OK;
+	}
+	else
+		return NS_ERROR_NULL_POINTER;
+}
+
+
+NS_IMETHODIMP nsMessage::SetMsgFolder(nsIMsgFolder *folder)
+{
+	mFolder = folder;
+	//We don't want to own folder, so don't AddRef
+	return NS_OK;
+}
+
+
+NS_IMETHODIMP nsMessage::SetMsgDBHdr(nsIMsgDBHdr *hdr)
+{
+	mMsgHdr = dont_QueryInterface(hdr);
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsMessage::GetMsgDBHdr(nsIMsgDBHdr **hdr)
+{
+	*hdr = mMsgHdr;
+	if(*hdr)
+	{
+		NS_ADDREF(*hdr);
+		return NS_OK;
+	}
+	else
+		return NS_ERROR_NULL_POINTER;
+}
+

mozilla/mailnews/base/util/nsMessage.h

@@ -0,0 +1,113 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/********************************************************************************************************
+ 
+   Interface for representing Messenger folders.
+ 
+*********************************************************************************************************/
+
+#ifndef nsMessage_h__
+#define nsMessage_h__
+
+#include "msgCore.h"
+#include "nsIMessage.h" /* include the interface we are going to support */
+#include "nsRDFResource.h"
+#include "nsIMsgHdr.h"
+#include "nsCOMPtr.h"
+
+
+class NS_MSG_BASE nsMessage: public nsRDFResource, public nsIDBMessage
+{
+public: 
+	nsMessage(void);
+	virtual ~nsMessage(void);
+
+	NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIMESSAGE
+  NS_DECL_NSIDBMESSAGE
+
+	NS_IMETHOD Init(const char *aURI);
+	//nsIMsgHdr
+	NS_IMETHOD GetProperty(const char *propertyName, nsString &resultProperty);
+    NS_IMETHOD SetProperty(const char *propertyName, nsString &propertyStr);
+    NS_IMETHOD GetUint32Property(const char *propertyName, PRUint32 *pResult);
+    NS_IMETHOD SetUint32Property(const char *propertyName, PRUint32 propertyVal);
+    NS_IMETHOD GetNumReferences(PRUint16 *result);
+    NS_IMETHOD GetStringReference(PRInt32 refNum, nsCString &resultReference);
+    NS_IMETHOD GetDate(PRTime *result);
+    NS_IMETHOD SetDate(PRTime date);
+    NS_IMETHOD SetMessageId(const char *messageId);
+    NS_IMETHOD SetReferences(const char *references);
+    NS_IMETHOD SetCCList(const char *ccList);
+    NS_IMETHOD SetRecipients(const char *recipients, PRBool recipientsIsNewsgroup);
+	NS_IMETHOD SetRecipientsArray(const char *names, const char *addresses, PRUint32 numAddresses);
+    NS_IMETHOD SetCCListArray(const char *names, const char *addresses, PRUint32 numAddresses);
+    NS_IMETHOD SetAuthor(const char *author);
+    NS_IMETHOD SetSubject(const char *subject);
+    NS_IMETHOD SetStatusOffset(PRUint32 statusOffset);
+
+	NS_IMETHOD GetAuthor(nsString *resultAuthor);
+	NS_IMETHOD GetSubject(nsString *resultSubject);
+	NS_IMETHOD GetRecipients(nsString *resultRecipients);
+	NS_IMETHOD GetCCList(nsString *ccList);
+	NS_IMETHOD GetMessageId(nsCString *resultMessageId);
+
+	NS_IMETHOD GetMime2DecodedAuthor(nsString *resultAuthor);
+	NS_IMETHOD GetMime2DecodedSubject(nsString *resultSubject);
+	NS_IMETHOD GetMime2DecodedRecipients(nsString *resultRecipients);
+
+	NS_IMETHOD GetAuthorCollationKey(nsString *resultAuthor);
+	NS_IMETHOD GetSubjectCollationKey(nsString *resultSubject);
+	NS_IMETHOD GetRecipientsCollationKey(nsString *resultRecipients);
+
+    // flag handling routines
+    NS_IMETHOD GetFlags(PRUint32 *result);
+    NS_IMETHOD SetFlags(PRUint32 flags);
+    NS_IMETHOD OrFlags(PRUint32 flags, PRUint32 *result);
+    NS_IMETHOD AndFlags(PRUint32 flags, PRUint32 *result);
+
+	// Mark message routines
+	NS_IMETHOD MarkRead(PRBool bRead);
+	NS_IMETHOD MarkFlagged(PRBool bFlagged);
+
+    NS_IMETHOD GetMessageKey(nsMsgKey *result);
+    NS_IMETHOD GetThreadId(nsMsgKey *result);
+    NS_IMETHOD SetThreadId(nsMsgKey inKey);
+    NS_IMETHOD SetMessageKey(nsMsgKey inKey);
+    NS_IMETHOD GetMessageSize(PRUint32 *result);
+    NS_IMETHOD SetMessageSize(PRUint32 messageSize);
+    NS_IMETHOD GetLineCount(PRUint32 *result);
+    NS_IMETHOD SetLineCount(PRUint32 lineCount);
+    NS_IMETHOD SetPriority(nsMsgPriority priority);
+    NS_IMETHOD SetPriority(const char *priority);
+    NS_IMETHOD GetMessageOffset(PRUint32 *result);
+    NS_IMETHOD GetStatusOffset(PRUint32 *result); 
+	NS_IMETHOD GetCharSet(nsString *result);
+    NS_IMETHOD GetPriority(nsMsgPriority *result);
+    NS_IMETHOD GetThreadParent(nsMsgKey *result);
+    NS_IMETHOD SetThreadParent(nsMsgKey inKey);
+
+protected:
+	nsIMsgFolder *mFolder;
+	nsCOMPtr<nsIMsgDBHdr> mMsgHdr;
+
+};
+
+#endif //nsMessage_h__
+

mozilla/mailnews/base/util/nsMsgDBFolder.cpp

@@ -0,0 +1,530 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "msgCore.h"
+#include "nsIMessage.h"
+#include "nsMsgDBFolder.h"
+#include "nsMsgFolderFlags.h"
+#include "nsIPref.h"
+#include "nsIMsgFolderCache.h"
+#include "nsIMsgFolderCacheElement.h"
+#include "nsIMsgMailSession.h"
+#include "nsMsgBaseCID.h"
+#include "nsIMsgMailNewsUrl.h"
+
+static NS_DEFINE_CID(kPrefServiceCID, NS_PREF_CID);
+static NS_DEFINE_CID(kMsgMailSessionCID, NS_MSGMAILSESSION_CID);
+
+NS_IMPL_ADDREF_INHERITED(nsMsgDBFolder, nsMsgFolder)
+NS_IMPL_RELEASE_INHERITED(nsMsgDBFolder, nsMsgFolder)
+
+NS_IMETHODIMP nsMsgDBFolder::QueryInterface(REFNSIID aIID, void** aInstancePtr)
+{
+	if (!aInstancePtr) return NS_ERROR_NULL_POINTER;
+	*aInstancePtr = nsnull;
+	if (aIID.Equals(nsCOMTypeInfo<nsIDBChangeListener>::GetIID()))
+	{
+		*aInstancePtr = NS_STATIC_CAST(nsIDBChangeListener*, this);
+	}              
+	else if (aIID.Equals(nsCOMTypeInfo<nsIUrlListener>::GetIID()))
+	{
+		*aInstancePtr = NS_STATIC_CAST(nsIUrlListener*, this);
+	}              
+
+	if(*aInstancePtr)
+	{
+		AddRef();
+		return NS_OK;
+	}
+
+	return nsRDFResource::QueryInterface(aIID, aInstancePtr);
+}
+
+nsMsgDBFolder::nsMsgDBFolder(void)
+: mCharset(""), mAddListener(PR_TRUE)
+{
+
+}
+
+nsMsgDBFolder::~nsMsgDBFolder(void)
+{
+	if(mDatabase)
+	{
+		mDatabase->RemoveListener(this);
+		mDatabase->Close(PR_TRUE);
+	}
+}
+
+NS_IMETHODIMP nsMsgDBFolder::StartFolderLoading(void)
+{
+	if(mDatabase)
+		mDatabase->RemoveListener(this);
+	mAddListener = PR_FALSE;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBFolder::EndFolderLoading(void)
+{
+	if(mDatabase)
+		mDatabase->AddListener(this);
+	mAddListener = PR_TRUE;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBFolder::GetThreads(nsISimpleEnumerator** threadEnumerator)
+{
+	nsresult rv = GetDatabase();
+	
+	if(NS_SUCCEEDED(rv))
+		return mDatabase->EnumerateThreads(threadEnumerator);
+	else
+		return rv;
+}
+
+NS_IMETHODIMP
+nsMsgDBFolder::GetThreadForMessage(nsIMessage *message, nsIMsgThread **thread)
+{
+	nsresult rv = GetDatabase();
+	if(NS_SUCCEEDED(rv))
+	{
+		nsCOMPtr<nsIMsgDBHdr> msgDBHdr;
+		nsCOMPtr<nsIDBMessage> dbMessage(do_QueryInterface(message, &rv));
+		if(NS_SUCCEEDED(rv))
+			rv = dbMessage->GetMsgDBHdr(getter_AddRefs(msgDBHdr));
+		if(NS_SUCCEEDED(rv))
+		{
+			rv = mDatabase->GetThreadContainingMsgHdr(msgDBHdr, thread);
+		}
+	}
+	return rv;
+
+}
+
+NS_IMETHODIMP
+nsMsgDBFolder::HasMessage(nsIMessage *message, PRBool *hasMessage)
+{
+	if(!hasMessage)
+		return NS_ERROR_NULL_POINTER;
+
+	nsresult rv = GetDatabase();
+
+	if(NS_SUCCEEDED(rv))
+	{
+		nsCOMPtr<nsIMsgDBHdr> msgDBHdr, msgDBHdrForKey;
+		nsCOMPtr<nsIDBMessage> dbMessage(do_QueryInterface(message, &rv));
+		nsMsgKey key;
+		if(NS_SUCCEEDED(rv))
+			rv = dbMessage->GetMsgDBHdr(getter_AddRefs(msgDBHdr));
+		if(NS_SUCCEEDED(rv))
+			rv = msgDBHdr->GetMessageKey(&key);
+		if(NS_SUCCEEDED(rv))
+			rv = mDatabase->ContainsKey(key, hasMessage);
+		
+	}
+	return rv;
+
+}
+
+NS_IMETHODIMP nsMsgDBFolder::GetCharset(PRUnichar * *aCharset)
+{
+	nsresult rv = NS_OK;
+	if(!aCharset)
+		return NS_ERROR_NULL_POINTER;
+
+	if(mCharset == "")
+	{
+		NS_WITH_SERVICE(nsIPref, prefs, kPrefServiceCID, &rv);
+
+		char *prefCharset = nsnull;
+		if (NS_SUCCEEDED(rv))
+		{
+			rv = prefs->CopyCharPref("intl.character_set_name", &prefCharset);
+		}
+  
+		nsString prefCharsetStr;
+		if(prefCharset)
+		{
+			prefCharsetStr = prefCharset;
+			PR_Free(prefCharset);
+		}
+		else
+		{
+			prefCharsetStr = "us-ascii";
+		}
+		*aCharset = prefCharsetStr.ToNewUnicode();
+	}
+	else
+	{
+		*aCharset = mCharset.ToNewUnicode();
+	}
+	return rv;
+}
+
+NS_IMETHODIMP nsMsgDBFolder::SetCharset(const PRUnichar * aCharset)
+{
+	nsresult rv;
+
+	nsCOMPtr<nsIDBFolderInfo> folderInfo;
+	nsCOMPtr<nsIMsgDatabase> db; 
+	rv = GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), getter_AddRefs(db));
+	if(NS_SUCCEEDED(rv))
+	{
+		nsString charset(aCharset);
+		rv = folderInfo->SetCharacterSet(&charset);
+		db->Commit(nsMsgDBCommitType::kLargeCommit);
+	}
+	return rv;
+}
+
+nsresult nsMsgDBFolder::ReadDBFolderInfo(PRBool force)
+{
+	// Since it turns out to be pretty expensive to open and close
+	// the DBs all the time, if we have to open it once, get everything
+	// we might need while we're here
+
+	nsresult result;
+
+	nsCOMPtr <nsIMsgFolderCache> folderCache;
+
+	NS_WITH_SERVICE(nsIMsgMailSession, mailSession, kMsgMailSessionCID, &result); 
+	if(NS_SUCCEEDED(result))
+	{
+		result = mailSession->GetFolderCache(getter_AddRefs(folderCache));
+		if (NS_SUCCEEDED(result) && folderCache)
+		{
+			char *uri;
+
+			result = GetURI(&uri);
+			if (NS_SUCCEEDED(result) && uri)
+			{
+				nsCOMPtr <nsIMsgFolderCacheElement> cacheElement;
+				result = folderCache->GetCacheElement(uri, PR_FALSE, getter_AddRefs(cacheElement));
+				if (NS_SUCCEEDED(result) && cacheElement)
+				{
+					result = ReadFromFolderCache(cacheElement);
+				}
+				PR_Free(uri);
+			}
+
+		}
+	}
+//	if (m_master->InitFolderFromCache (this))
+//		return err;
+
+	if (force || !(mPrefFlags & MSG_FOLDER_PREF_CACHED))
+    {
+        nsCOMPtr<nsIDBFolderInfo> folderInfo;
+        nsCOMPtr<nsIMsgDatabase> db; 
+        result = GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), getter_AddRefs(db));
+        if(NS_SUCCEEDED(result))
+        {
+			mIsCachable = PR_TRUE;
+            if (folderInfo)
+            {
+
+	            folderInfo->GetFlags(&mPrefFlags);
+                mPrefFlags |= MSG_FOLDER_PREF_CACHED;
+                folderInfo->SetFlags(mPrefFlags);
+
+				folderInfo->GetNumMessages(&mNumTotalMessages);
+				folderInfo->GetNumNewMessages(&mNumUnreadMessages);
+
+				//These should be put in IMAP folder only.
+				//folderInfo->GetImapTotalPendingMessages(&mNumPendingTotalMessages);
+				//folderInfo->GetImapUnreadPendingMessages(&mNumPendingUnreadMessages);
+
+				folderInfo->GetCharacterSet(&mCharset);
+        
+				if (db) {
+					PRBool hasnew;
+					nsresult rv;
+					rv = db->HasNew(&hasnew);
+					if (NS_FAILED(rv)) return rv;
+					if (!hasnew && mNumPendingUnreadMessages <= 0) {
+						ClearFlag(MSG_FOLDER_FLAG_GOT_NEW);
+					}
+				}
+            }
+
+        }
+        if (db)
+	        db->Close(PR_FALSE);
+    }
+
+	return result;
+	
+}
+
+nsresult nsMsgDBFolder::SendFlagNotifications(nsISupports *item, PRUint32 oldFlags, PRUint32 newFlags)
+{
+	nsresult rv = NS_OK;
+
+	PRUint32 changedFlags = oldFlags ^ newFlags;
+	if((changedFlags & MSG_FLAG_READ) || (changedFlags & MSG_FLAG_REPLIED)
+		|| (changedFlags & MSG_FLAG_FORWARDED)|| (changedFlags & MSG_FLAG_NEW))
+	{
+		rv = NotifyPropertyFlagChanged(item, "Status", oldFlags, newFlags);
+	}
+	else if((changedFlags & MSG_FLAG_MARKED))
+	{
+		rv = NotifyPropertyFlagChanged(item, "Flagged", oldFlags, newFlags);
+	}
+		return rv;
+}
+
+NS_IMETHODIMP
+nsMsgDBFolder::GetMsgDatabase(nsIMsgDatabase** aMsgDatabase)
+{
+    if (!aMsgDatabase || !mDatabase)
+        return NS_ERROR_NULL_POINTER;
+    *aMsgDatabase = mDatabase;
+    NS_ADDREF(*aMsgDatabase);
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBFolder::OnKeyChange(nsMsgKey aKeyChanged, PRUint32 aOldFlags, PRUint32 aNewFlags, 
+                         nsIDBChangeListener * aInstigator)
+{
+	nsCOMPtr<nsIMsgDBHdr> pMsgDBHdr;
+	nsresult rv = mDatabase->GetMsgHdrForKey(aKeyChanged, getter_AddRefs(pMsgDBHdr));
+	if(NS_SUCCEEDED(rv) && pMsgDBHdr)
+	{
+		nsCOMPtr<nsIMessage> message;
+		rv = CreateMessageFromMsgDBHdr(pMsgDBHdr, getter_AddRefs(message));
+		if(NS_SUCCEEDED(rv))
+		{
+			nsCOMPtr<nsISupports> msgSupports(do_QueryInterface(message, &rv));
+			if(NS_SUCCEEDED(rv))
+			{
+				SendFlagNotifications(msgSupports, aOldFlags, aNewFlags);
+			}
+			UpdateSummaryTotals(PR_TRUE);
+		}
+	}
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBFolder::OnKeyDeleted(nsMsgKey aKeyChanged, nsMsgKey  aParentKey, PRInt32 aFlags, 
+                          nsIDBChangeListener * aInstigator)
+{
+	nsCOMPtr<nsIMsgDBHdr> pMsgDBHdr;
+	nsresult rv = mDatabase->GetMsgHdrForKey(aKeyChanged, getter_AddRefs(pMsgDBHdr));
+	if(NS_SUCCEEDED(rv) && pMsgDBHdr)
+	{
+		nsCOMPtr<nsIMessage> message;
+		rv = CreateMessageFromMsgDBHdr(pMsgDBHdr, getter_AddRefs(message));
+		if(NS_SUCCEEDED(rv))
+		{
+			nsCOMPtr<nsISupports> msgSupports(do_QueryInterface(message, &rv));
+			if(NS_SUCCEEDED(rv))
+			{
+				NotifyItemDeleted(msgSupports);
+			}
+			UpdateSummaryTotals(PR_TRUE);
+		}
+	}
+
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBFolder::OnKeyAdded(nsMsgKey aKeyChanged, nsMsgKey  aParentKey , PRInt32 aFlags, 
+                        nsIDBChangeListener * aInstigator)
+{
+	nsresult rv;
+	nsCOMPtr<nsIMsgDBHdr> msgDBHdr;
+	rv = mDatabase->GetMsgHdrForKey(aKeyChanged, getter_AddRefs(msgDBHdr));
+	if(NS_SUCCEEDED(rv) && msgDBHdr)
+	{
+		nsCOMPtr<nsIMessage> message;
+		rv = CreateMessageFromMsgDBHdr(msgDBHdr, getter_AddRefs(message));
+		if(NS_SUCCEEDED(rv))
+		{
+			nsCOMPtr<nsISupports> msgSupports(do_QueryInterface(message));
+			if(msgSupports)
+			{
+				NotifyItemAdded(msgSupports);
+			}
+			UpdateSummaryTotals(PR_TRUE);
+		}
+	}
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBFolder::OnParentChanged(nsMsgKey aKeyChanged, nsMsgKey oldParent, nsMsgKey newParent, 
+						nsIDBChangeListener * aInstigator)
+{
+	return NS_OK;
+}
+
+
+NS_IMETHODIMP nsMsgDBFolder::OnAnnouncerGoingAway(nsIDBChangeAnnouncer *
+													 instigator)
+{
+    if (mDatabase)
+    {
+        mDatabase->RemoveListener(this);
+        mDatabase = null_nsCOMPtr();
+    }
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBFolder::ManyHeadersToDownload(PRBool *retval)
+{
+	PRInt32 numTotalMessages;
+
+	if (!retval)
+		return NS_ERROR_NULL_POINTER;
+	if (!mDatabase)
+		*retval = PR_TRUE;
+	else if (NS_SUCCEEDED(GetTotalMessages(PR_FALSE, &numTotalMessages)) && numTotalMessages <= 0)
+		*retval = PR_TRUE;
+	else
+		*retval = PR_FALSE;
+	return NS_OK;
+}
+
+
+nsresult nsMsgDBFolder::ReadFromFolderCache(nsIMsgFolderCacheElement *element)
+{
+	nsresult rv = NS_OK;
+	char *charset;
+
+	element->GetInt32Property("flags", &mPrefFlags);
+	element->GetInt32Property("totalMsgs", &mNumTotalMessages);
+	element->GetInt32Property("totalUnreadMsgs", &mNumUnreadMessages);
+
+	element->GetStringProperty("charset", &charset);
+
+#ifdef DEBUG_bienvenu1
+	char *uri;
+
+	GetURI(&uri);
+	printf("read total %ld for %s\n", mNumTotalMessages, uri);
+	PR_Free(uri);
+#endif
+	mCharset = charset;
+	PR_FREEIF(charset);
+
+    mPrefFlags |= MSG_FOLDER_PREF_CACHED;
+	return rv;
+}
+
+NS_IMETHODIMP nsMsgDBFolder::WriteToFolderCache(nsIMsgFolderCache *folderCache)
+{
+	nsCOMPtr <nsIEnumerator> aEnumerator;
+
+	nsresult rv = GetSubFolders(getter_AddRefs(aEnumerator));
+	if(NS_FAILED(rv)) 
+		return rv;
+
+	char *uri = nsnull;
+	rv = GetURI(&uri);
+
+	if (folderCache)
+	{
+		nsCOMPtr <nsIMsgFolderCacheElement> cacheElement;
+		rv = folderCache->GetCacheElement(uri, PR_TRUE, getter_AddRefs(cacheElement));
+		if (NS_SUCCEEDED(rv) && cacheElement)
+			rv = WriteToFolderCacheElem(cacheElement);
+	}
+	PR_FREEIF(uri);
+
+	
+	nsCOMPtr<nsISupports> aItem;
+
+	rv = aEnumerator->First();
+	if (!NS_SUCCEEDED(rv))
+		return NS_OK;	// it's OK, there are no sub-folders.
+
+	while(NS_SUCCEEDED(rv))
+	{
+		rv = aEnumerator->CurrentItem(getter_AddRefs(aItem));
+		if (NS_FAILED(rv)) break;
+		nsCOMPtr<nsIMsgFolder> aMsgFolder(do_QueryInterface(aItem, &rv));
+		if (NS_SUCCEEDED(rv))
+		{
+			if (folderCache)
+			{
+				rv = aMsgFolder->WriteToFolderCache(folderCache);
+				if (!NS_SUCCEEDED(rv))
+					break;
+			}
+		}
+		rv = aEnumerator->Next();
+		if (!NS_SUCCEEDED(rv))
+		{
+			rv = NS_OK;
+			break;
+		}
+	}
+	return rv;
+}
+
+NS_IMETHODIMP nsMsgDBFolder::WriteToFolderCacheElem(nsIMsgFolderCacheElement *element)
+{
+	nsresult rv = NS_OK;
+
+	element->SetInt32Property("flags", mPrefFlags);
+	element->SetInt32Property("totalMsgs", mNumTotalMessages);
+	element->SetInt32Property("totalUnreadMsgs", mNumUnreadMessages);
+
+	element->SetStringProperty("charset", (const char *) nsCAutoString(mCharset));
+
+#ifdef DEBUG_bienvenu1
+	char *uri;
+
+	GetURI(&uri);
+	printf("writing total %ld for %s\n", mNumTotalMessages, uri);
+	PR_Free(uri);
+#endif
+	return rv;
+}
+
+NS_IMETHODIMP
+nsMsgDBFolder::MarkAllMessagesRead(void)
+{
+	nsresult rv = GetDatabase();
+	
+	if(NS_SUCCEEDED(rv))
+		return mDatabase->MarkAllRead(nsnull);
+
+	return rv;
+}
+
+NS_IMETHODIMP
+nsMsgDBFolder::OnStartRunningUrl(nsIURI *aUrl)
+{
+	NS_PRECONDITION(aUrl, "just a sanity check");
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgDBFolder::OnStopRunningUrl(nsIURI *aUrl, nsresult aExitCode)
+{
+	NS_PRECONDITION(aUrl, "just a sanity check");
+	nsCOMPtr<nsIMsgMailNewsUrl> mailUrl = do_QueryInterface(aUrl);
+	if (mailUrl)
+	{
+		PRBool updatingFolder = PR_FALSE;
+		if (NS_SUCCEEDED(mailUrl->GetUpdatingFolder(&updatingFolder)) && updatingFolder)
+		{
+			NotifyFolderLoaded();
+		}
+	}
+    return NS_OK;
+}

mozilla/mailnews/base/util/nsMsgDBFolder.h

@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef nsMsgDBFolder_h__
+#define nsMsgDBFolder_h__
+
+#include "msgCore.h"
+#include "nsMsgFolder.h" 
+#include "nsIDBFolderInfo.h"
+#include "nsIMsgDatabase.h"
+#include "nsIMessage.h"
+#include "nsCOMPtr.h"
+#include "nsIDBChangeListener.h"
+#include "nsIUrlListener.h"
+
+class nsIMsgFolderCacheElement;
+ /* 
+  * nsMsgDBFolder
+  * class derived from nsMsgFolder for those folders that use an nsIMsgDatabase
+  */ 
+
+class NS_MSG_BASE nsMsgDBFolder:  public nsMsgFolder,
+                                        public nsIDBChangeListener,
+                                        public nsIUrlListener
+{
+public: 
+	nsMsgDBFolder(void);
+	virtual ~nsMsgDBFolder(void);
+  NS_DECL_NSIDBCHANGELISTENER
+  
+	NS_IMETHOD  StartFolderLoading(void);
+	NS_IMETHOD  EndFolderLoading(void);
+	NS_IMETHOD GetThreads(nsISimpleEnumerator** threadEnumerator);
+	NS_IMETHOD GetThreadForMessage(nsIMessage *message, nsIMsgThread **thread);
+	NS_IMETHOD HasMessage(nsIMessage *message, PRBool *hasMessage);
+	NS_IMETHOD GetCharset(PRUnichar * *aCharset);
+	NS_IMETHOD SetCharset(const PRUnichar * aCharset);
+
+  NS_IMETHOD GetMsgDatabase(nsIMsgDatabase** aMsgDatabase);
+
+	NS_DECL_ISUPPORTS_INHERITED
+
+	NS_DECL_NSIURLLISTENER
+
+	NS_IMETHOD WriteToFolderCache(nsIMsgFolderCache *folderCache);
+	NS_IMETHOD WriteToFolderCacheElem(nsIMsgFolderCacheElement *element);
+	NS_IMETHOD ManyHeadersToDownload(PRBool *_retval);
+
+	NS_IMETHOD MarkAllMessagesRead(void);
+
+protected:
+	virtual nsresult ReadDBFolderInfo(PRBool force);
+	virtual nsresult GetDatabase() = 0;
+	virtual nsresult SendFlagNotifications(nsISupports *item, PRUint32 oldFlags, PRUint32 newFlags);
+	nsresult ReadFromFolderCache(nsIMsgFolderCacheElement *element);
+
+protected:
+	nsCOMPtr<nsIMsgDatabase> mDatabase;  
+	nsString mCharset;
+	PRBool mAddListener;
+
+
+};
+
+#endif

mozilla/mailnews/base/util/nsMsgFolder.h

@@ -0,0 +1,268 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/********************************************************************************************************
+ 
+   Interface for representing Messenger folders.
+ 
+*********************************************************************************************************/
+
+#ifndef nsMsgFolder_h__
+#define nsMsgFolder_h__
+
+#include "msgCore.h"
+#include "nsIMsgFolder.h" /* include the interface we are going to support */
+#include "nsRDFResource.h"
+#include "nsIDBFolderInfo.h"
+#include "nsIMsgDatabase.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsCOMPtr.h"
+#include "nsIURL.h"
+ /* 
+  * MsgFolder
+  */ 
+
+class NS_MSG_BASE nsMsgFolder: public nsRDFResource, public nsIMsgFolder
+{
+public: 
+  nsMsgFolder(void);
+  virtual ~nsMsgFolder(void);
+
+  NS_DECL_ISUPPORTS_INHERITED
+
+  NS_DECL_NSICOLLECTION
+  NS_DECL_NSIFOLDER
+  // eventually this will be an instantiable class, and we should
+  // use this macro:
+  // NS_DECL_NSIMSGFOLDER
+  
+  // right now a few of these methods are left abstract, and
+  // are commented out below
+  
+  // begin NS_DECL_NSIMSGFOLDER
+  NS_IMETHOD AddUnique(nsISupports *element);
+  NS_IMETHOD ReplaceElement(nsISupports *element, nsISupports *newElement);
+  NS_IMETHOD GetMessages(nsISimpleEnumerator **_retval);
+  NS_IMETHOD GetThreads(nsISimpleEnumerator **_retval);
+  NS_IMETHOD StartFolderLoading(void);
+  NS_IMETHOD EndFolderLoading(void);
+  NS_IMETHOD UpdateFolder(void);
+  NS_IMETHOD GetThreadForMessage(nsIMessage *message, nsIMsgThread **_retval);
+  NS_IMETHOD HasMessage(nsIMessage *message, PRBool *_retval);
+  NS_IMETHOD GetVisibleSubFolders(nsIEnumerator **_retval);
+  NS_IMETHOD GetPrettiestName(PRUnichar * *aPrettiestName);
+  NS_IMETHOD GetFolderURL(char * *aFolderURL);
+  NS_IMETHOD GetDeleteIsMoveToTrash(PRBool *aDeleteIsMoveToTrash);
+  NS_IMETHOD GetShowDeletedMessages(PRBool *aShowDeletedMessages);
+  NS_IMETHOD GetServer(nsIMsgIncomingServer * *aServer);
+  NS_IMETHOD GetIsServer(PRBool *aIsServer);
+  NS_IMETHOD OnCloseFolder(void);
+  NS_IMETHOD Delete(void);
+  NS_IMETHOD DeleteSubFolders(nsISupportsArray *folders);
+  NS_IMETHOD PropagateDelete(nsIMsgFolder *folder, PRBool deleteStorage);
+  NS_IMETHOD RecursiveDelete(PRBool deleteStorage);
+  NS_IMETHOD CreateSubfolder(const char *folderName);
+  NS_IMETHOD Compact(void);
+  NS_IMETHOD EmptyTrash(void);
+  NS_IMETHOD Rename(const char *name);
+  NS_IMETHOD Adopt(nsIMsgFolder *srcFolder, PRUint32 *outPos);
+  NS_IMETHOD ContainsChildNamed(const char *name, PRBool *_retval);
+  NS_IMETHOD IsAncestorOf(nsIMsgFolder *folder, PRBool *_retval);
+  NS_IMETHOD GenerateUniqueSubfolderName(const char *prefix, nsIMsgFolder *otherFolder, char **_retval); 
+  NS_IMETHOD UpdateSummaryTotals(PRBool force);
+  NS_IMETHOD SummaryChanged(void);
+  NS_IMETHOD GetNumUnread(PRBool deep, PRInt32 *_retval);
+  NS_IMETHOD GetTotalMessages(PRBool deep, PRInt32 *_retval);
+  NS_IMETHOD GetExpungedBytesCount(PRUint32 *aExpungedBytesCount);
+  NS_IMETHOD GetDeletable(PRBool *aDeletable);
+  NS_IMETHOD GetCanCreateChildren(PRBool *aCanCreateChildren);
+  NS_IMETHOD GetCanBeRenamed(PRBool *aCanBeRenamed);
+  NS_IMETHOD GetRequiresCleanup(PRBool *aRequiresCleanup);
+  NS_IMETHOD ClearRequiresCleanup(void);
+  NS_IMETHOD ManyHeadersToDownload(PRBool *_retval);
+  NS_IMETHOD GetKnowsSearchNntpExtension(PRBool *aKnowsSearchNntpExtension);
+  NS_IMETHOD GetAllowsPosting(PRBool *aAllowsPosting);
+  NS_IMETHOD GetDisplayRecipients(PRBool *aDisplayRecipients);
+   NS_IMETHOD GetRelativePathName(char * *aRelativePathName);
+  NS_IMETHOD GetSizeOnDisk(PRUint32 *aSizeOnDisk);
+  NS_IMETHOD RememberPassword(const char *password);
+  NS_IMETHOD GetRememberedPassword(char * *aRememberedPassword);
+  NS_IMETHOD UserNeedsToAuthenticateForFolder(PRBool displayOnly, PRBool *_retval);
+  NS_IMETHOD GetUsername(char * *aUsername);
+  NS_IMETHOD GetHostname(char * *aHostname);
+  NS_IMETHOD SetFlag(PRUint32 flag);
+  NS_IMETHOD ClearFlag(PRUint32 flag);
+  NS_IMETHOD GetFlag(PRUint32 flag, PRBool *_retval);
+  NS_IMETHOD ToggleFlag(PRUint32 flag);
+  NS_IMETHOD OnFlagChange(PRUint32 flag);
+  NS_IMETHOD GetFlags(PRUint32 *aFlags);
+  NS_IMETHOD GetFoldersWithFlag(PRUint32 flags, nsIMsgFolder **result, PRUint32 resultsize, PRUint32 *numFolders);
+  NS_IMETHOD GetExpansionArray(nsISupportsArray *expansionArray);
+  // NS_IMETHOD DeleteMessages(nsISupportsArray *message, nsITransactionManager *txnMgr, PRBool deleteStorage);
+  NS_IMETHOD CopyMessages(nsIMsgFolder *srcFolder, nsISupportsArray *messages, PRBool isMove, nsITransactionManager *txnMgr, nsIMsgCopyServiceListener *listener);
+  NS_IMETHOD CopyFileMessage(nsIFileSpec *fileSpec, nsIMessage *msgToReplace, PRBool isDraft, nsITransactionManager *txnMgr, nsIMsgCopyServiceListener *listener);
+  NS_IMETHOD AcquireSemaphore(nsISupports *semHolder);
+  NS_IMETHOD ReleaseSemaphore(nsISupports *semHolder);
+  NS_IMETHOD TestSemaphore(nsISupports *semHolder, PRBool *_retval);
+  NS_IMETHOD GetLocked(PRBool *aLocked);
+  // NS_IMETHOD CreateMessageFromMsgDBHdr(nsIMsgDBHdr *msgDBHdr, nsIMessage **_retval);
+  NS_IMETHOD GetNewMessages(void);
+  // NS_IMETHOD WriteToFolderCache(nsIMsgFolderCache *folderCache);
+  // NS_IMETHOD GetCharset(PRUnichar * *aCharset);
+  // NS_IMETHOD SetCharset(const PRUnichar * aCharset);
+  NS_IMETHOD GetBiffState(PRUint32 *aBiffState);
+  NS_IMETHOD SetBiffState(PRUint32 aBiffState);
+  NS_IMETHOD GetNumNewMessages(PRInt32 *aNumNewMessages);
+  NS_IMETHOD SetNumNewMessages(PRInt32 aNumNewMessages);
+  NS_IMETHOD GetNewMessagesNotificationDescription(PRUnichar * *aNewMessagesNotificationDescription);
+  NS_IMETHOD GetRootFolder(nsIMsgFolder * *aRootFolder);
+  NS_IMETHOD GetMsgDatabase(nsIMsgDatabase * *aMsgDatabase);
+  NS_IMETHOD GetPath(nsIFileSpec * *aPath);
+  NS_IMETHOD MarkMessagesRead(nsISupportsArray *messages, PRBool markRead);
+  NS_IMETHOD MarkAllMessagesRead(void);
+  NS_IMETHOD MarkMessagesFlagged(nsISupportsArray *messages, PRBool markFlagged);
+  NS_IMETHOD GetChildWithURI(const char *uri, PRBool deep, nsIMsgFolder **_retval); 
+
+  // end NS_DECL_NSIMSGFOLDER
+  
+  // nsRDFResource overrides
+  NS_IMETHOD Init(const char* aURI);
+  
+#if 0
+  static nsresult GetRoot(nsIMsgFolder* *result);
+#endif
+  // Gets the URL that represents the given message.  Returns a newly
+  // created string that must be free'd using XP_FREE().
+  // If the db is NULL, then returns a URL that represents the entire
+  // folder as a whole.
+#ifdef HAVE_DB
+  NS_IMETHOD BuildUrl(nsMsgDatabase *db, nsMsgKey key, char ** url);
+  
+  // updates num messages and num unread - should be pure virtual
+  // when I get around to implementing in all subclasses?
+  NS_IMETHOD GetTotalMessagesInDB(PRUint32 *totalMessages) const;					// How many messages in database.
+	// These functions are used for tricking the front end into thinking that we have more 
+	// messages than are really in the DB.  This is usually after and IMAP message copy where
+	// we don't want to do an expensive select until the user actually opens that folder
+	// These functions are called when MSG_Master::GetFolderLineById is populating a MSG_FolderLine
+	// struct used by the FE
+	int32			GetNumPendingUnread(PRBool deep = PR_FALSE);
+	int32			GetNumPendingTotalMessages(PRBool deep = PR_FALSE);
+	
+  void			ChangeNumPendingUnread(int32 delta);
+  void			ChangeNumPendingTotalMessages(int32 delta);
+
+
+  NS_IMETHOD SetFolderPrefFlags(PRUint32 flags);
+  NS_IMETHOD GetFolderPrefFlags(PRUint32 *flags);
+
+
+  NS_IMETHOD SetLastMessageLoaded(nsMsgKey lastMessageLoaded);
+  NS_IMETHOD GetLastMessageLoaded();
+#endif
+
+
+#ifdef HAVE_ADMINURL
+  NS_IMETHOD GetAdminUrl(MWContext *context, MSG_AdminURLType type);
+  NS_IMETHOD HaveAdminUrl(MSG_AdminURLType type, PRBool *hadAdminUrl);
+#endif
+
+
+#ifdef HAVE_PANE
+  NS_IMETHOD	MarkAllRead(MSG_Pane *pane, PRBool deep);
+  NS_IMETHOD SetFlagInAllFolderPanes(PRUint32 which);
+#endif
+
+#ifdef HAVE_NET
+  NS_IMETHOD EscapeMessageId(const char *messageId, const char **escapeMessageID);
+  NS_IMETHOD ShouldPerformOperationOffline(PRBool *performOffline);
+#endif
+
+#ifdef HAVE_CACHE
+	virtual nsresult WriteToCache(XP_File);
+	virtual nsresult ReadFromCache(char *);
+	virtual PRBool IsCachable();
+	void SkipCacheTokens(char **ppBuf, int numTokens);
+#endif
+
+#ifdef DOES_FOLDEROPERATIONS
+	int DownloadToTempFileAndUpload(MessageCopyInfo *copyInfo, nsMsgKeyArray &keysToSave, MSG_FolderInfo *dstFolder, nsMsgDatabase *sourceDB);
+	void UpdateMoveCopyStatus(MWContext *context, PRBool isMove, int32 curMsgCount, int32 totMessages);
+#endif
+
+	virtual nsresult GetDBFolderInfoAndDB(nsIDBFolderInfo **folderInfo, nsIMsgDatabase **db) = 0;
+
+
+	NS_IMETHOD MatchName(nsString *name, PRBool *matches);
+
+
+protected:
+	nsresult NotifyPropertyChanged(char *property, char* oldValue, char* newValue);
+	nsresult NotifyPropertyFlagChanged(nsISupports *item, char *property, PRUint32 oldValue,
+												PRUint32 newValue);
+	nsresult NotifyItemAdded(nsISupports *item);
+	nsresult NotifyItemDeleted(nsISupports *item);
+
+	nsresult NotifyFolderLoaded();
+	// this is a little helper function that is not part of the public interface. 
+	// we use it to get the IID of the incoming server for the derived folder.
+	// w/out a function like this we would have to implement GetServer in each
+	// derived folder class.
+	virtual const char* GetIncomingServerType() = 0;
+
+protected:
+  PRUint32 mFlags;
+  nsIFolder *mParent;     //This won't be refcounted for ownership reasons.
+  PRInt32 mNumUnreadMessages;        /* count of unread messages (-1 means
+                                         unknown; -2 means unknown but we already
+                                         tried to find out.) */
+  PRInt32 mNumTotalMessages;         /* count of existing messages. */
+  nsCOMPtr<nsISupportsArray> mSubFolders;
+  nsVoidArray *mListeners; //This can't be an nsISupportsArray because due to
+													 //ownership issues, listeners can't be AddRef'd
+
+  PRInt32 mPrefFlags;       // prefs like MSG_PREF_OFFLINE, MSG_PREF_ONE_PANE, etc
+  nsISupports *mSemaphoreHolder; // set when the folder is being written to
+								//Due to ownership issues, this won't be AddRef'd.
+
+  nsIMsgIncomingServer* m_server; //this won't be addrefed....ownership issue here
+
+#ifdef HAVE_DB
+  nsMsgKey	m_lastMessageLoaded;
+#endif
+  // These values are used for tricking the front end into thinking that we have more 
+  // messages than are really in the DB.  This is usually after and IMAP message copy where
+  // we don't want to do an expensive select until the user actually opens that folder
+  PRInt32 mNumPendingUnreadMessages;
+  PRInt32 mNumPendingTotalMessages;
+
+  PRUint32	mBiffState;
+  PRInt32	mNumNewBiffMessages;
+
+  PRBool mIsCachable;
+
+  //
+  // stuff from the uri
+  //
+  
+  PRBool mIsServer;
+  nsString mName;
+  
+};
+
+#endif

mozilla/mailnews/base/util/nsMsgGroupRecord.cpp

@@ -0,0 +1,598 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "msgCore.h"    // precompiled header...
+#include "prlog.h"
+
+#include "nsMsgGroupRecord.h"
+
+#include "plstr.h"
+#include "prmem.h"
+#include "nsEscape.h"
+#include "nsCRT.h"
+
+// mscott: this is lame...I know....
+#define MK_OUT_OF_MEMORY  1
+
+const PRUint32 F_ISGROUP			 = 0x00000001;
+const PRUint32 F_EXPANDED			 = 0x00000002;
+const PRUint32 F_CATCONT			 = 0x00000004;
+const PRUint32 F_VIRTUAL			 = 0x00000008;
+const PRUint32 F_DIRTY			 = 0x00000010;
+const PRUint32 F_DESCENDENTSLOADED = 0x00000020;
+const PRUint32 F_HTMLOKGROUP		 = 0x00000040;
+const PRUint32 F_HTMLOKTREE		 = 0x00000080;
+const PRUint32 F_NEEDEXTRAINFO	 = 0x00000100;
+const PRUint32 F_DOESNOTEXIST		 = 0x00000200;
+const PRUint32 RUNTIMEFLAGS =		// Flags to be sure *not* to write to disk.
+	F_DIRTY | F_DESCENDENTSLOADED | F_EXPANDED;
+
+
+
+int
+nsMsgGroupRecord::GroupNameCompare(const char* name1, const char* name2,
+								  char delimiter, PRBool caseInsensitive)
+{
+	if (caseInsensitive)
+	{
+		while (*name1 && (nsCRT::ToUpper(*name1) == nsCRT::ToUpper(*name2))) {
+			name1++;
+			name2++;
+		}		
+	}
+	else
+	{
+		while (*name1 && *name1 == *name2) {
+			name1++;
+			name2++;
+		}
+	}
+
+	if (*name1 && *name2) {
+		if (*name1 == delimiter) return -1;
+		if (*name2 == delimiter) return 1;
+	}
+
+	if (caseInsensitive)
+		return int(nsCRT::ToUpper(*name1)) - int(nsCRT::ToUpper(*name2));
+	else
+		return int(*name1) - int(*name2);
+}
+
+
+nsMsgGroupRecord*
+nsMsgGroupRecord::Create(nsMsgGroupRecord* parent, const char* partname,
+						PRInt64 aTime, PRInt32 uniqueid, PRInt32 fileoffset)
+{
+	nsMsgGroupRecord* result = new nsMsgGroupRecord(parent, partname,
+												  aTime, uniqueid, fileoffset);
+	if (result && partname && !result->m_partname) {
+		// We ran out of memory.
+		delete result;
+		result = NULL;
+	}
+	result->InitializeSibling();
+	return result;
+}
+
+MOZ_DECL_CTOR_COUNTER(nsMsgGroupRecord);
+
+nsMsgGroupRecord::nsMsgGroupRecord(nsMsgGroupRecord* parent, const char* partname,
+								 PRInt64 aTime, PRInt32 uniqueid, PRInt32 fileoffset,
+								 char delimiter /* = '.' */)
+{
+	MOZ_COUNT_CTOR(nsMsgGroupRecord);
+	int length;
+	m_prettyname = NULL;
+	m_parent = parent;
+	m_children = NULL;
+	m_sibling = NULL;
+	m_flags = 0;
+	m_partname = NULL;
+	m_addtime = aTime;
+	m_uniqueId = uniqueid;
+	m_fileoffset = fileoffset;
+	m_delimiter = delimiter;
+	if (partname) {
+		length = PL_strlen(partname);
+		// PR_ASSERT(parent != NULL);
+		m_partname = new char [length + 1];
+		if (!m_partname) {
+			m_parent = NULL;
+			return;
+		}
+		PL_strcpy(m_partname, partname);
+	}
+}
+
+
+nsMsgGroupRecord::~nsMsgGroupRecord()
+{
+	MOZ_COUNT_DTOR(nsMsgGroupRecord);
+	delete [] m_partname;
+	m_partname = NULL;
+	delete [] m_prettyname;
+	m_prettyname = NULL;
+	while (m_children) {
+		delete m_children;
+	}
+	m_children = NULL;
+	if (m_parent) {
+		nsMsgGroupRecord** ptr;
+		for (ptr = &(m_parent->m_children);
+			 *ptr;
+			 ptr = &((*ptr)->m_sibling)) {
+			if (*ptr == this) {
+				*ptr = m_sibling;
+				break;
+			}
+		}
+	}
+}
+
+void nsMsgGroupRecord::InitializeSibling()
+{
+	if (m_parent) {
+		PR_ASSERT(m_partname != NULL);
+		nsMsgGroupRecord** ptr;
+		for (ptr = &(m_parent->m_children) ; *ptr ; ptr = &((*ptr)->m_sibling)) {
+			int comp = GroupNameCompare((*ptr)->m_partname, m_partname, m_delimiter, IsIMAPGroupRecord());
+			PR_ASSERT(comp != 0);
+			if (comp >= 0) break;
+		}
+		m_sibling = *ptr;
+		*ptr = this;
+	}
+}
+
+
+nsMsgGroupRecord*
+nsMsgGroupRecord::FindDescendant(const char* name)
+{
+	if (!name || !*name) return this;
+	char* ptr = PL_strchr(name, m_delimiter);
+	if (ptr) *ptr = '\0';
+	nsMsgGroupRecord* child;
+	for (child = m_children ; child ; child = child->m_sibling) {
+		if (PL_strcmp(child->m_partname, name) == 0) {
+			break;
+		}
+	}
+	if (ptr) {
+		*ptr++ = m_delimiter;
+		if (child) {
+			return child->FindDescendant(ptr);
+		}
+	}
+	return child;
+}
+
+
+nsMsgGroupRecord*
+nsMsgGroupRecord::GetSiblingOrAncestorSibling()
+{
+	if (m_sibling) return m_sibling;
+	if (m_parent) return m_parent->GetSiblingOrAncestorSibling();
+	return NULL;
+}
+
+nsMsgGroupRecord*
+nsMsgGroupRecord::GetNextAlphabetic()
+{
+	nsMsgGroupRecord* result;
+	if (m_children) result = m_children;
+	else result = GetSiblingOrAncestorSibling();
+#ifdef DEBUG_slowAndParanoid
+	if (result) {
+		char* ptr1 = GetFullName();
+		char* ptr2 = result->GetFullName();
+		PR_ASSERT(GroupNameCompare(ptr1, ptr2) < 0);
+		delete [] ptr1;
+		delete [] ptr2;
+	}
+#endif
+	return result;
+}
+
+nsMsgGroupRecord*
+nsMsgGroupRecord::GetNextAlphabeticNoCategories()
+{
+	if (IsCategoryContainer()) {
+		return GetSiblingOrAncestorSibling();
+	} else {
+		return GetNextAlphabetic();
+	}
+}
+
+
+char*
+nsMsgGroupRecord::GetFullName()
+{
+	int length = 0;
+	nsMsgGroupRecord* ptr;
+	for (ptr = this ; ptr ; ptr = ptr->m_parent) {
+		if (ptr->m_partname) length += PL_strlen(ptr->m_partname) + 1;
+	}
+	PR_ASSERT(length > 0);
+	if (length <= 0) return NULL;
+	char* result = new char [length];
+	if (result) {
+		SuckInName(result);
+		PR_ASSERT(int(PL_strlen(result)) + 1 == length);
+	}
+	return result;
+}
+
+
+char* 
+nsMsgGroupRecord::SuckInName(char* ptr)
+{
+	if (m_parent && m_parent->m_partname) {
+		ptr = m_parent->SuckInName(ptr);
+		*ptr++ = m_delimiter;
+	}
+	PL_strcpy(ptr, m_partname);
+	return ptr + PL_strlen(ptr);
+}
+
+
+
+int
+nsMsgGroupRecord::SetPrettyName(const char* name)
+{
+	if (name == NULL && m_prettyname == NULL) return 0;
+	m_flags |= F_DIRTY;
+	delete [] m_prettyname;
+	m_prettyname = NULL;
+	if (!name || !*name) {
+		return 0;
+	}
+	int length = PL_strlen(name);
+	m_prettyname = new char [length + 1];
+	if (!m_prettyname) {
+		return MK_OUT_OF_MEMORY;
+	}
+	PL_strcpy(m_prettyname, name);
+	return 1;
+}
+
+
+PRBool
+nsMsgGroupRecord::IsCategory()
+{
+	return GetCategoryContainer() != NULL;
+}
+
+PRBool
+nsMsgGroupRecord::IsCategoryContainer()
+{
+	return (m_flags & F_CATCONT) != 0;
+}
+
+PRBool
+nsMsgGroupRecord::NeedsExtraInfo()
+{
+	return (m_flags & F_NEEDEXTRAINFO) != 0;
+}
+
+int
+nsMsgGroupRecord::SetNeedsExtraInfo(PRBool value)
+{
+	return TweakFlag(F_NEEDEXTRAINFO, value);
+}
+
+
+int
+nsMsgGroupRecord::SetIsCategoryContainer(PRBool value)
+{
+	// refuse to set a group to be a category container if it has a parent
+	// that's a category container.
+	if (! (value && GetCategoryContainer()))
+		return TweakFlag(F_CATCONT, value);
+	else
+		return 0;
+}
+
+
+nsMsgGroupRecord*
+nsMsgGroupRecord::GetCategoryContainer()
+{
+	if (IsCategoryContainer()) return NULL;
+	for (nsMsgGroupRecord* ptr = m_parent ; ptr ; ptr = ptr->m_parent) {
+		if (ptr->IsCategoryContainer()) return ptr;
+	}
+	return NULL;
+}
+
+
+nsresult
+nsMsgGroupRecord::IsVirtual(PRBool *retval)
+{
+	*retval =( (m_flags & F_VIRTUAL) != 0);
+    return NS_OK;
+}
+
+nsresult
+nsMsgGroupRecord::SetIsVirtual(PRBool value)
+{
+	TweakFlag(F_VIRTUAL, value);
+    return NS_OK;
+}
+
+
+
+PRBool
+nsMsgGroupRecord::IsExpanded()
+{
+	return (m_flags & F_EXPANDED) != 0;
+}
+
+int
+nsMsgGroupRecord::SetIsExpanded(PRBool value)
+{
+	return TweakFlag(F_EXPANDED, value);
+}
+
+
+PRBool
+nsMsgGroupRecord::IsHTMLOKGroup()
+{
+	return (m_flags & F_HTMLOKGROUP) != 0;
+}
+
+int
+nsMsgGroupRecord::SetIsHTMLOKGroup(PRBool value)
+{
+	return TweakFlag(F_HTMLOKGROUP, value);
+}
+
+
+
+PRBool
+nsMsgGroupRecord::IsHTMLOKTree()
+{
+	return (m_flags & F_HTMLOKTREE) != 0;
+}
+
+int
+nsMsgGroupRecord::SetIsHTMLOKTree(PRBool value)
+{
+	return TweakFlag(F_HTMLOKTREE, value);
+}
+
+
+
+PRBool
+nsMsgGroupRecord::IsGroup()
+{
+	return (m_flags & F_ISGROUP) != 0;
+}
+
+int
+nsMsgGroupRecord::SetIsGroup(PRBool value)
+{
+	return TweakFlag(F_ISGROUP, value);
+}
+
+
+PRBool
+nsMsgGroupRecord::IsDescendentsLoaded()
+{
+	return (m_flags & F_DESCENDENTSLOADED) != 0;
+}
+
+
+int
+nsMsgGroupRecord::SetIsDescendentsLoaded(PRBool value)
+{
+	PR_ASSERT(value);			// No reason we'd ever unset this.
+	TweakFlag(F_DESCENDENTSLOADED, PR_TRUE);
+	nsMsgGroupRecord* child;
+	for (child = m_children ; child ; child = child->m_sibling) {
+		child->SetIsDescendentsLoaded(value);
+	}
+	return 0;
+}
+
+PRBool nsMsgGroupRecord::DoesNotExistOnServer()
+{
+	return (m_flags & F_DOESNOTEXIST) != 0;
+}
+
+int nsMsgGroupRecord::SetDoesNotExistOnServer(PRBool value)
+{
+	if (value)		// turn off group flag if doesn't exist on server.
+		TweakFlag(F_ISGROUP, PR_FALSE);
+	return TweakFlag(F_DOESNOTEXIST, value);
+}
+
+int
+nsMsgGroupRecord::TweakFlag(PRUint32 flagbit, PRBool value)
+{
+	if (value) {
+		if (!(m_flags & flagbit)) {
+			m_flags |= flagbit;
+			if (flagbit & ~RUNTIMEFLAGS)
+				m_flags |= F_DIRTY;
+			return 1;
+		}
+	} else {
+		if (m_flags & flagbit) {
+			m_flags &= ~flagbit;
+			if (flagbit & ~RUNTIMEFLAGS)
+				m_flags |= F_DIRTY;
+			return 1;
+		}
+	}
+	return 0;
+}
+
+
+PRInt32
+nsMsgGroupRecord::GetNumKids()
+{
+	PRInt32 result = 0;
+	nsMsgGroupRecord* child;
+	for (child = m_children ; child ; child = child->m_sibling) {
+		if (IsIMAPGroupRecord())
+			result++;
+		else
+			if (child->m_flags & F_ISGROUP) result++;
+
+		if (!IsIMAPGroupRecord())
+			result += child->GetNumKids();
+	}
+	return result;
+}
+
+
+
+
+char*
+nsMsgGroupRecord::GetSaveString()
+{
+	char* pretty = NULL;
+	char* result = nsnull;
+	
+	if (m_prettyname) {
+		pretty = nsEscape(m_prettyname, url_XAlphas);
+		if (!pretty) return NULL;
+	}
+	char* fullname = GetFullName();
+	if (!fullname) return NULL; {
+		long nAddTime;
+		LL_L2I(nAddTime, m_addtime);
+        result = PR_smprintf("%s,%s,%lx,%lx,%lx" MSG_LINEBREAK,
+							   fullname, pretty ? pretty : "",
+							   (long) (m_flags & ~RUNTIMEFLAGS),
+							   nAddTime,
+							   (long) m_uniqueId);
+	}
+	delete [] fullname;
+	if (pretty) nsCRT::free(pretty);
+	m_flags &= ~F_DIRTY;
+	return result;
+}
+
+
+PRBool
+nsMsgGroupRecord::IsDirty()
+{
+	return (m_flags & F_DIRTY) != 0;
+}
+
+
+PRInt32
+nsMsgGroupRecord::GetDepth()
+{
+	PRInt32 result = 0;
+	nsMsgGroupRecord* tmp = m_parent;
+	while (tmp) {
+		tmp = tmp->m_parent;
+		result++;
+	}
+	return result;
+}
+
+
+
+
+nsMsgGroupRecord*
+nsMsgGroupRecord::Create(nsMsgGroupRecord* parent, const char* saveline,
+						PRInt32 savelinelength, PRInt32 fileoffset)
+{
+	char* tmp;
+	char* ptr;
+	char* endptr;
+	char* partname;
+	char* prettyname;
+	PRInt32 flags;
+	PRInt32 addtime;
+	PRInt32 uniqueid;
+	nsMsgGroupRecord* result = NULL;
+
+	if (savelinelength < 0) savelinelength = PL_strlen(saveline);
+	tmp = (char*) PR_Malloc(savelinelength + 1);
+	if (!tmp) return NULL;
+	PL_strncpy(tmp, saveline, savelinelength);
+	tmp[savelinelength] = '\0';
+	ptr = PL_strchr(tmp, ',');
+	PR_ASSERT(ptr);
+	if (!ptr) goto FAIL;
+	*ptr++ = '\0';
+	partname = PL_strrchr(tmp, '.');
+	if (!partname) partname = tmp;
+	else partname++;
+
+#ifdef DEBUG_slowAndParanoid
+	if (parent->m_partname) {
+		char* parentname = parent->GetFullName();
+		PR_ASSERT(partname > tmp && partname[-1] == '.');
+		partname[-1] = '\0';
+		PR_ASSERT(PL_strcmp(parentname, tmp) == 0);
+		partname[-1] = '.';
+		delete [] parentname;
+		parentname = NULL;
+	} else {
+		PR_ASSERT(partname == tmp);
+	}
+#endif
+
+	endptr = PL_strchr(ptr, ',');
+	PR_ASSERT(endptr);
+	if (!endptr) goto FAIL;
+	*endptr++ = '\0';
+	prettyname = nsUnescape(ptr);
+
+	ptr = endptr;
+	endptr = PL_strchr(ptr, ',');
+	PR_ASSERT(endptr);
+	if (!endptr) goto FAIL;
+	*endptr++ = '\0';
+	flags = strtol(ptr, NULL, 16);
+
+	ptr = endptr;
+	endptr = PL_strchr(ptr, ',');
+	PR_ASSERT(endptr);
+	if (!endptr) goto FAIL;
+	*endptr++ = '\0';
+	addtime = strtol(ptr, NULL, 16);
+
+	ptr = endptr;
+	uniqueid = strtol(ptr, NULL, 16);
+
+	PRInt64 llAddtime;
+	LL_I2L(llAddtime, addtime);
+	result = Create(parent, partname, llAddtime, uniqueid, fileoffset);
+	if (result) {
+		PRBool maybeCategoryContainer = flags & F_CATCONT;
+		flags &= ~F_CATCONT;
+		result->m_flags = flags;
+		if (maybeCategoryContainer)
+			result->SetIsCategoryContainer(PR_TRUE);
+		if (prettyname && *prettyname) result->SetPrettyName(prettyname);
+	}
+
+FAIL:
+	PR_Free(tmp);
+	return result;
+	
+}
+
+
+

mozilla/mailnews/base/util/nsMsgGroupRecord.h

@@ -0,0 +1,160 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// This class should only be used by the subscribe UI and by newshost.cpp.
+// And, well, a bit by the category code.  Everyone else should use the stuff
+// in newshost.h.
+
+#ifndef _nsMsgGroupRecord_h_
+#define _nsMsgGroupRecord_h__
+
+#include "msgCore.h"
+#include "prtypes.h"
+#include "nsISupports.h"
+
+class nsIMAPGroupRecord;
+
+class NS_MSG_BASE nsMsgGroupRecord {
+public:
+	static nsMsgGroupRecord* Create(nsMsgGroupRecord* parent,
+								   const char* partname,
+                                   PRInt64 m_addtime,
+								   PRInt32 uniqueid,
+								   PRInt32 fileoffset);
+	static nsMsgGroupRecord* Create(nsMsgGroupRecord* parent,
+								   const char* saveline,
+								   PRInt32 savelinelength,
+								   PRInt32 fileoffset);
+
+
+	virtual void	InitializeSibling();
+	virtual PRBool IsIMAPGroupRecord() { return PR_FALSE; }
+	virtual nsIMAPGroupRecord *GetIMAPGroupRecord() { return 0; }
+	
+	// This is just like PL_strcmp(), except it works on news group names.
+	// A container groupname is always less than any contained groups.
+	// So, "netscape.devs-client-technical" > "netscape.devs.directory", even
+	// though PL_strcmp says otherwise.  (YICK!)
+	static int GroupNameCompare(const char* name1,
+								const char* name2,
+								char delimiter = '.',
+								PRBool caseInsensitive = PR_FALSE);
+
+
+	virtual ~nsMsgGroupRecord();
+
+	nsMsgGroupRecord* FindDescendant(const char* name);
+
+	nsMsgGroupRecord* GetParent() {return m_parent;}
+	nsMsgGroupRecord* GetChildren() {return m_children;}
+	nsMsgGroupRecord* GetSibling() {return m_sibling;}
+	nsMsgGroupRecord* GetSiblingOrAncestorSibling();
+	nsMsgGroupRecord* GetNextAlphabetic();
+
+	nsMsgGroupRecord* GetNextAlphabeticNoCategories();
+
+	const char* GetPartName() {return m_partname;}
+
+	// The resulting string must be free'd using delete[].
+	char* GetFullName();
+
+	const char* GetPrettyName() {return m_prettyname;}
+	int SetPrettyName(const char* prettyname);
+
+	PRInt64 GetAddTime() {return m_addtime;}
+
+	virtual PRBool IsCategory();
+	virtual PRBool IsCategoryContainer();
+	virtual int SetIsCategoryContainer(PRBool value);
+
+	nsMsgGroupRecord* GetCategoryContainer();
+
+	// Get/Set whether this is a virtual newsgroup.
+	nsresult IsVirtual(PRBool *retval);
+    nsresult SetIsVirtual(PRBool value);
+
+	// Get/Set whether this is really a newsgroup (and not just a container
+	// for newsgroups).
+	virtual PRBool IsGroup();
+	int SetIsGroup(PRBool value);
+
+	PRBool IsDescendentsLoaded();
+	int SetIsDescendentsLoaded(PRBool value);
+
+	PRBool IsExpanded();
+	int SetIsExpanded(PRBool value);
+
+	PRBool IsHTMLOKGroup();
+	int SetIsHTMLOKGroup(PRBool value);
+
+	PRBool IsHTMLOKTree();
+	int SetIsHTMLOKTree(PRBool value);
+
+	PRBool NeedsExtraInfo();
+	int SetNeedsExtraInfo(PRBool value);
+
+	PRBool DoesNotExistOnServer();
+	int SetDoesNotExistOnServer(PRBool value);
+
+	PRInt32 GetUniqueID() {return m_uniqueId;}
+
+	PRInt32 GetFileOffset() {return m_fileoffset;}
+	int SetFileOffset(PRInt32 value) {m_fileoffset = value; return 0;}
+
+	// Get the number of descendents (not including ourself) that are
+	// really newsgroups.
+	PRInt32 GetNumKids();
+
+	// Gets the string that represents this group in the save file.  The
+	// resulting string must be free'd with PR_Free().
+	char* GetSaveString();
+
+	PRBool IsDirty();			// Whether this record has had changes made
+								// to it.  Cleared by calls to GetSaveString().
+
+	PRInt32 GetDepth();			// Returns how deep in the heirarchy we are.
+								// Basically, the number of dots in the full
+								// newsgroup name, plus 1.
+	virtual char GetHierarchySeparator() { return '.'; }
+
+protected:
+	nsMsgGroupRecord(nsMsgGroupRecord* parent,
+								   const char* partname,
+								   PRInt64 m_addtime,
+								   PRInt32 uniqueid,
+								   PRInt32 fileoffset,
+								   char delimiter = '.');
+	int TweakFlag(PRUint32 flagbit, PRBool value);
+	char* SuckInName(char* ptr);
+
+	char* m_partname;
+	char* m_prettyname;
+	nsMsgGroupRecord* m_parent;
+	nsMsgGroupRecord* m_children;
+	nsMsgGroupRecord* m_sibling;
+	PRUint32 m_flags;
+	PRInt64 m_addtime;
+	PRInt32 m_uniqueId;
+	PRInt32 m_fileoffset;
+	char m_delimiter;
+};
+
+
+
+
+#endif /* _grec_h_ */

mozilla/mailnews/base/util/nsMsgI18N.cpp

@@ -0,0 +1,363 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */ 
+
+// as does this
+#define NS_IMPL_IDS
+#include "nsIServiceManager.h"
+#include "nsICharsetConverterManager.h"
+
+#include "nsISupports.h"
+#include "nsIPref.h"
+#include "nsIMimeConverter.h"
+#include "msgCore.h"
+#include "rosetta_mailnews.h"
+#include "nsMsgI18N.h"
+#include "nsFileSpec.h"
+#include "nsFileStream.h"
+#include "nsMsgMimeCID.h"
+#include "nsMimeTypes.h"
+#include "nsIEntityConverter.h"
+#include "nsISaveAsCharset.h"
+
+static NS_DEFINE_CID(kPrefCID, NS_PREF_CID);
+static NS_DEFINE_CID(kCMimeConverterCID, NS_MIME_CONVERTER_CID);
+static NS_DEFINE_CID(kCharsetConverterManagerCID, NS_ICHARSETCONVERTERMANAGER_CID);
+static NS_DEFINE_CID(kEntityConverterCID, NS_ENTITYCONVERTER_CID);
+static NS_DEFINE_CID(kSaveAsCharsetCID, NS_SAVEASCHARSET_CID);
+
+//
+// International functions necessary for composition
+//
+
+// Convert an unicode string to a C string with a given charset.
+nsresult ConvertFromUnicode(const nsString& aCharset, 
+                            const nsString& inString,
+                            char** outCString)
+{
+  nsresult res;
+
+  NS_WITH_SERVICE(nsICharsetConverterManager, ccm, kCharsetConverterManagerCID, &res); 
+
+  if(NS_SUCCEEDED(res) && (nsnull != ccm)) {
+    nsIUnicodeEncoder* encoder = nsnull;
+    nsString convCharset;
+
+    // map to converter charset
+    if (aCharset.EqualsIgnoreCase("us-ascii")) {
+      convCharset.SetString("iso-8859-1");
+    }
+    else {
+      convCharset = aCharset; 
+    }
+
+    // get an unicode converter
+    res = ccm->GetUnicodeEncoder(&convCharset, &encoder);
+    if(NS_SUCCEEDED(res) && (nsnull != encoder)) {
+      PRUnichar *unichars = (PRUnichar *) inString.GetUnicode();
+      PRInt32 unicharLength = inString.Length();
+      PRInt32 dstLength;
+      res = encoder->GetMaxLength(unichars, unicharLength, &dstLength);
+      // allocale an output buffer
+      *outCString = (char *) PR_Malloc(dstLength + 1);
+      if (nsnull != *outCString) {
+        PRInt32 oldUnicharLength = unicharLength;
+        char *tempCString = *outCString;
+        PRInt32 totalCLength = 0;
+        while (1) {
+          res = encoder->Convert(unichars, &unicharLength, tempCString, &dstLength);
+
+          // increment for destination
+          tempCString += dstLength;
+          totalCLength += dstLength;
+
+          // break: this is usually the case
+          // source length <= zero and no error or unrecoverable error
+          if (0 >= unicharLength || NS_ERROR_UENC_NOMAPPING != res) {
+            break;
+          }
+          // could not map unicode to the destination charset, skip one unichar and continue
+          // increment for source unicode, skip one unichar
+          unichars += unicharLength + 1;
+          oldUnicharLength -= (unicharLength + 1);
+          unicharLength = oldUnicharLength;
+          // estimate target length again
+          (void) encoder->GetMaxLength(unichars, unicharLength, &dstLength);
+        }
+        (*outCString)[totalCLength] = '\0';
+      }
+      else {
+        res = NS_ERROR_OUT_OF_MEMORY;
+      }
+      NS_IF_RELEASE(encoder);
+    }    
+  }
+  return res;
+}
+
+// Convert a C string to an unicode string.
+nsresult ConvertToUnicode(const nsString& aCharset, 
+                          const char* inCString, 
+                          nsString& outString)
+{
+  nsresult res;
+  NS_WITH_SERVICE(nsICharsetConverterManager, ccm, kCharsetConverterManagerCID, &res); 
+
+  if(NS_SUCCEEDED(res) && (nsnull != ccm)) {
+    nsIUnicodeDecoder* decoder = nsnull;
+    PRUnichar *unichars;
+    PRInt32 unicharLength;
+    nsString convCharset;
+
+    // map to converter charset
+    if (aCharset.EqualsIgnoreCase("us-ascii")) {
+      convCharset.SetString("iso-8859-1");
+    }
+    else {
+      convCharset = aCharset; 
+    }
+    // get an unicode converter
+    res = ccm->GetUnicodeDecoder(&convCharset, &decoder);
+    if(NS_SUCCEEDED(res) && (nsnull != decoder)) {
+      PRInt32 srcLen = PL_strlen(inCString);
+      res = decoder->GetMaxLength(inCString, srcLen, &unicharLength);
+      // allocale an output buffer
+      unichars = (PRUnichar *) PR_Malloc(unicharLength * sizeof(PRUnichar));
+      if (unichars != nsnull) {
+        // convert to unicode
+        res = decoder->Convert(inCString, &srcLen, unichars, &unicharLength);
+        outString.SetString(unichars, unicharLength);
+        PR_Free(unichars);
+      }
+      else {
+        res = NS_ERROR_OUT_OF_MEMORY;
+      }
+      NS_IF_RELEASE(decoder);
+    }    
+  }  
+  return res;
+}
+
+// Charset to be used for the internatl processing.
+const char *msgCompHeaderInternalCharset()
+{
+  // UTF-8 is a super set of us-ascii. 
+  // We can use the same string manipulation methods as us-ascii without breaking non us-ascii characters. 
+  return "UTF-8";
+}
+
+// MIME encoder, output string should be freed by PR_FREE
+char * nsMsgI18NEncodeMimePartIIStr(const char *header, const char *charset, PRBool bUseMime) 
+{
+  // No MIME, just duplicate the string.
+  if (PR_FALSE == bUseMime) {
+    return PL_strdup(header);
+  }
+
+  char *encodedString = nsnull;
+  nsIMimeConverter *converter;
+  nsresult res = nsComponentManager::CreateInstance(kCMimeConverterCID, nsnull, 
+                                           nsCOMTypeInfo<nsIMimeConverter>::GetIID(), (void **)&converter);
+  if (NS_SUCCEEDED(res) && nsnull != converter) {
+    res = converter->EncodeMimePartIIStr_UTF8(header, charset, kMIME_ENCODED_WORD_SIZE, &encodedString);
+    NS_RELEASE(converter);
+  }
+  return NS_SUCCEEDED(res) ? encodedString : nsnull;
+}
+
+// MIME decoder
+nsresult nsMsgI18NDecodeMimePartIIStr(const nsString& header, nsString& charset, nsString& decodedString)
+{
+  nsIMimeConverter *converter;
+  nsresult res = nsComponentManager::CreateInstance(kCMimeConverterCID, nsnull, 
+                                                    nsCOMTypeInfo<nsIMimeConverter>::GetIID(), (void **)&converter);
+  if (NS_SUCCEEDED(res) && nsnull != converter) {
+    res = converter->DecodeMimePartIIStr(header, charset, decodedString);
+    NS_RELEASE(converter);
+  }
+  return res;
+}
+
+// Get a default mail character set.
+char * nsMsgI18NGetDefaultMailCharset()
+{
+  nsresult res = NS_OK;
+  char * retVal = nsnull;
+  NS_WITH_SERVICE(nsIPref, prefs, kPrefCID, &res); 
+  if (nsnull != prefs && NS_SUCCEEDED(res))
+  {
+      char *prefValue;
+	  res = prefs->CopyCharPref("intl.character_set_name", &prefValue);
+	  
+	  if (NS_SUCCEEDED(res)) 
+	  {
+  		//TODO: map to mail charset (e.g. Shift_JIS -> ISO-2022-JP) bug#3941.
+  		 retVal = prefValue;
+	  }
+	  else 
+		  retVal = PL_strdup("iso-8859-1");
+  }
+
+  return (nsnull != retVal) ? retVal : PL_strdup("iso-8859-1");
+}
+
+// Return True if a charset is stateful (e.g. JIS).
+PRBool nsMsgI18Nstateful_charset(const char *charset)
+{
+  //TODO: use charset manager's service
+  return (PL_strcasecmp(charset, "iso-2022-jp") == 0);
+}
+
+// Check 7bit in a given buffer.
+// This is expensive (both memory and performance).
+// The check would be very simple if applied to an unicode text (e.g. nsString or utf-8).
+// Possible optimazaion is to search ESC(0x1B) in case of iso-2022-jp and iso-2022-kr.
+// Or convert and check line by line.
+PRBool nsMsgI18N7bit_data_part(const char *charset, const char *inString, const PRUint32 size)
+{
+  char *aCString;
+  nsString aCharset(charset);
+  nsString outString;
+  nsresult res;
+  
+  aCString = (char *) PR_Malloc(size + 1);
+  if (nsnull != aCString) {
+    PL_strncpy(aCString, inString, size); // make a C string
+    res = ConvertToUnicode(aCharset, aCString, outString);
+    PR_Free(aCString);
+    if (NS_SUCCEEDED(res)) {
+      for (PRInt32 i = 0; i < outString.Length(); i++) {
+        if (outString.CharAt(i) > 127) {
+          return PR_FALSE;
+        }
+      }
+    }
+  }
+  return PR_TRUE;  // all 7 bit
+}
+
+// Simple parser to parse META charset. 
+// It only supports the case when the description is within one line. 
+const char * 
+nsMsgI18NParseMetaCharset(nsFileSpec* fileSpec) 
+{ 
+  static char charset[65]; 
+  char buffer[512]; 
+  nsInputFileStream fileStream(*fileSpec); 
+
+  *charset = '\0'; 
+
+  while (!fileStream.eof() && !fileStream.failed() && 
+         fileStream.is_open()) { 
+    fileStream.readline(buffer, 512); 
+    if (*buffer == CR || *buffer == LF || *buffer == 0) 
+      continue; 
+
+    for (int i = 0; i < (int)PL_strlen(buffer); i++) { 
+      buffer[i] = toupper(buffer[i]); 
+    } 
+
+    if (PL_strstr(buffer, "/HEAD")) 
+      break; 
+
+    if (PL_strstr(buffer, "META") && 
+        PL_strstr(buffer, "HTTP-EQUIV") && 
+        PL_strstr(buffer, "CONTENT-TYPE") && 
+        PL_strstr(buffer, "CHARSET") 
+        ) 
+    { 
+      char *cp = PL_strstr(PL_strstr(buffer, "CHARSET"), "=") + 1; 
+      char seps[]   = " \"\'"; 
+      char *token; 
+      char* newStr; 
+      token = nsCRT::strtok(cp, seps, &newStr); 
+      if (token != NULL) 
+      { 
+        PL_strcpy(charset, token); 
+      } 
+    } 
+  } 
+
+  return charset; 
+} 
+
+nsresult nsMsgI18NConvertToEntity(const nsString& inString, nsString* outString)
+{
+  nsresult res;
+
+  outString->SetString("");
+  nsCOMPtr <nsIEntityConverter> entityConv;
+  res = nsComponentManager::CreateInstance(kEntityConverterCID, NULL, 
+                                           nsIEntityConverter::GetIID(), getter_AddRefs(entityConv));
+  if(NS_SUCCEEDED(res)) {
+    PRUnichar *entities = NULL;
+    res = entityConv->ConvertToEntities(inString.GetUnicode(), nsIEntityConverter::html40Latin1, &entities);
+    if (NS_SUCCEEDED(res) && (NULL != entities)) {
+      outString->SetString(entities);
+      nsAllocator::Free(entities);
+     }
+   }
+ 
+  return res;
+}
+
+nsresult nsMsgI18NSaveAsCharset(const char* contentType, const char *charset, const PRUnichar* inString, char** outString)
+{
+  NS_ASSERTION(contentType, "null ptr- contentType");
+  NS_ASSERTION(charset, "null ptr- charset");
+  NS_ASSERTION(outString, "null ptr- outString");
+  if(!contentType || !charset || !outString)
+    return NS_ERROR_NULL_POINTER;
+  *outString = NULL;
+
+  PRBool bTEXT_HTML = PR_FALSE;
+  nsresult res;
+
+  if (!nsCRT::strcasecmp(contentType, TEXT_HTML)) {
+    bTEXT_HTML = PR_TRUE;
+  }
+  else if (nsCRT::strcasecmp(contentType, TEXT_PLAIN)) {
+    return NS_ERROR_ILLEGAL_VALUE;  // not supported type
+  }
+
+  nsCOMPtr <nsISaveAsCharset> aConv;  // charset converter plus entity, NCR generation
+  res = nsComponentManager::CreateInstance(kSaveAsCharsetCID, NULL, 
+                                           nsISaveAsCharset::GetIID(), getter_AddRefs(aConv));
+  if(NS_SUCCEEDED(res)) {
+    // attribute: 
+    // html text - charset conv then fallback to entity or NCR
+    // plain text - charset conv then fallback to '?'
+    res = aConv->Init(charset, 
+                      bTEXT_HTML ? 
+                      nsISaveAsCharset::attr_EntityAfterCharsetConv + nsISaveAsCharset::attr_FallbackDecimalNCR : 
+                      nsISaveAsCharset::attr_plainTextDefault + nsISaveAsCharset::attr_FallbackQuestionMark, 
+                      nsIEntityConverter::html40);
+    if (NS_SUCCEEDED(res)) {
+      res = aConv->Convert(inString, outString);
+    }
+  }
+ 
+  return res;
+}
+
+// RICHIE - not sure about this one?? need to see what it did in the old
+// world.
+char *
+nsMsgI18NGetAcceptLanguage(void)
+{
+  return "en";
+}

mozilla/mailnews/base/util/nsMsgI18N.h

@@ -0,0 +1,49 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _nsMsgI18N_H_
+#define _nsMsgI18N_H_
+
+#include "nscore.h"
+#include "msgCore.h"
+
+
+NS_MSG_BASE char      *nsMsgI18NEncodeMimePartIIStr(const char *header, const char *charset, PRBool bUseMime);
+NS_MSG_BASE PRBool    nsMsgI18Nstateful_charset(const char *charset);
+NS_MSG_BASE PRBool    nsMsgI18N7bit_data_part(const char *charset, const char *string, const PRUint32 size);
+NS_MSG_BASE char      *nsMsgI18NGetAcceptLanguage(void); 
+
+NS_MSG_BASE const char *msgCompHeaderInternalCharset(void);
+
+NS_MSG_BASE char * nsMsgI18NGetDefaultMailCharset(void);
+NS_MSG_BASE nsresult ConvertFromUnicode(const nsString& aCharset, 
+                                   const nsString& inString,
+                                   char** outCString);
+NS_MSG_BASE nsresult ConvertToUnicode(const nsString& aCharset, 
+                                 const char* inCString, 
+                                 nsString& outString);
+
+NS_MSG_BASE nsresult nsMsgI18NDecodeMimePartIIStr(const nsString& header, nsString& charset, nsString& decodedString);
+
+NS_MSG_BASE const char *nsMsgI18NParseMetaCharset(nsFileSpec* fileSpec);
+
+NS_MSG_BASE nsresult nsMsgI18NConvertToEntity(const nsString& inString, nsString* outString);
+
+NS_MSG_BASE nsresult nsMsgI18NSaveAsCharset(const char* contentType, const char* charset, const PRUnichar* inString, char** outString);
+
+#endif /* _nsMsgI18N_H_ */

mozilla/mailnews/base/util/nsMsgIdentity.cpp

@@ -0,0 +1,356 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "msgCore.h" // for pre-compiled headers
+#include "nsMsgIdentity.h"
+#include "nsIPref.h"
+#include "nsXPIDLString.h"
+
+static NS_DEFINE_CID(kPrefServiceCID, NS_PREF_CID);
+
+NS_IMPL_ISUPPORTS2(nsMsgIdentity,
+                   nsIMsgIdentity,
+                   nsIShutdownListener)
+
+nsMsgIdentity::nsMsgIdentity():
+  m_signature(0),
+  m_vCard(0),
+  m_identityKey(0),
+  m_prefs(0)
+{
+	NS_INIT_REFCNT();
+}
+
+nsMsgIdentity::~nsMsgIdentity()
+{
+  PR_FREEIF(m_identityKey);
+  if (m_prefs) nsServiceManager::ReleaseService(kPrefServiceCID,
+                                                m_prefs,
+                                                nsnull);
+}
+
+nsresult
+nsMsgIdentity::getPrefService()
+{
+  if (m_prefs) return NS_OK;
+  return nsServiceManager::GetService(kPrefServiceCID,
+                                      nsCOMTypeInfo<nsIPref>::GetIID(),
+                                      (nsISupports**)&m_prefs,
+                                      this);
+}
+
+
+/* called if the prefs service goes offline */
+NS_IMETHODIMP
+nsMsgIdentity::OnShutdown(const nsCID& aClass, nsISupports *service)
+{
+  if (aClass.Equals(kPrefServiceCID)) {
+    if (m_prefs) nsServiceManager::ReleaseService(kPrefServiceCID, m_prefs);
+    m_prefs = nsnull;
+  }
+
+  return NS_OK;
+}
+
+/*
+ * accessors for pulling values directly out of preferences
+ * instead of member variables, etc
+ */
+
+/* convert an identity key and preference name
+   to mail.identity.<identityKey>.<prefName>
+*/
+char *
+nsMsgIdentity::getPrefName(const char *identityKey,
+                           const char *prefName)
+{
+  return PR_smprintf("mail.identity.%s.%s", identityKey, prefName);
+}
+
+// this will be slightly faster than the above, and allows
+// the "default" identity preference root to be set in one place
+char *
+nsMsgIdentity::getDefaultPrefName(const char *fullPrefName)
+{
+  return PR_smprintf("mail.identity.default.%s", fullPrefName);
+}
+
+/* The following are equivalent to the nsIPref's Get/CopyXXXPref
+   except they construct the preference name with the above function
+*/
+nsresult
+nsMsgIdentity::getBoolPref(const char *prefname,
+                           PRBool *val)
+{
+  nsresult rv = getPrefService();
+  if (NS_FAILED(rv)) return rv;
+  
+  char *fullPrefName = getPrefName(m_identityKey, prefname);
+  rv = m_prefs->GetBoolPref(fullPrefName, val);
+  PR_Free(fullPrefName);
+
+  if (NS_FAILED(rv))
+    rv = getDefaultBoolPref(prefname, val);
+  
+  return rv;
+}
+
+nsresult
+nsMsgIdentity::getDefaultBoolPref(const char *prefname,
+                                        PRBool *val) {
+  
+  nsresult rv = getPrefService();
+  if (NS_FAILED(rv)) return rv;
+  
+  char *fullPrefName = getDefaultPrefName(prefname);
+  rv = m_prefs->GetBoolPref(fullPrefName, val);
+  PR_Free(fullPrefName);
+
+  if (NS_FAILED(rv)) {
+    *val = PR_FALSE;
+    rv = NS_OK;
+  }
+  return rv;
+}
+
+nsresult
+nsMsgIdentity::setBoolPref(const char *prefname,
+                           PRBool val)
+{
+  nsresult rv = getPrefService();
+  if (NS_FAILED(rv)) return rv;
+  
+  char *prefName = getPrefName(m_identityKey, prefname);
+  rv = m_prefs->SetBoolPref(prefName, val);
+  PR_Free(prefName);
+  return rv;
+}
+
+nsresult
+nsMsgIdentity::getCharPref(const char *prefname,
+                           char **val)
+{
+  nsresult rv = getPrefService();
+  if (NS_FAILED(rv)) return rv;
+  
+  char *fullPrefName = getPrefName(m_identityKey, prefname);
+  rv = m_prefs->CopyCharPref(fullPrefName, val);
+  PR_Free(fullPrefName);
+
+  if (NS_FAILED(rv))
+    rv = getDefaultCharPref(prefname, val);
+
+  return rv;
+}
+
+nsresult
+nsMsgIdentity::getDefaultCharPref(const char *prefname,
+                                        char **val)
+{
+  nsresult rv = getPrefService();
+  if (NS_FAILED(rv)) return rv;
+  
+  char *fullPrefName = getDefaultPrefName(prefname);
+  rv = m_prefs->CopyCharPref(fullPrefName, val);
+  PR_Free(fullPrefName);
+
+  if (NS_FAILED(rv)) {
+    *val = nsnull;              // null is ok to return here
+    rv = NS_OK;
+  }
+  return rv;
+}
+
+nsresult
+nsMsgIdentity::setCharPref(const char *prefname,
+                           const char *val)
+{
+  nsresult rv = getPrefService();
+  if (NS_FAILED(rv)) return rv;
+  
+  rv = NS_OK;
+  char *prefName = getPrefName(m_identityKey, prefname);
+  if (val) 
+    rv = m_prefs->SetCharPref(prefName, val);
+  else
+    m_prefs->ClearUserPref(prefName);
+  PR_Free(prefName);
+  return rv;
+}
+
+nsresult
+nsMsgIdentity::getIntPref(const char *prefname,
+                                PRInt32 *val)
+{
+  nsresult rv = getPrefService();
+  if (NS_FAILED(rv)) return rv;
+  
+  char *fullPrefName = getPrefName(m_identityKey, prefname);
+  rv = m_prefs->GetIntPref(fullPrefName, val);
+  PR_Free(fullPrefName);
+
+  if (NS_FAILED(rv))
+	rv = getDefaultIntPref(prefname, val);
+
+  return rv;
+}
+
+nsresult
+nsMsgIdentity::getDefaultIntPref(const char *prefname,
+                                        PRInt32 *val) {
+  
+  nsresult rv = getPrefService();
+  if (NS_FAILED(rv)) return rv;
+  
+  char *fullPrefName = getDefaultPrefName(prefname);
+  rv = m_prefs->GetIntPref(fullPrefName, val);
+  PR_Free(fullPrefName);
+
+  if (NS_FAILED(rv)) {
+    *val = 0;
+    rv = NS_OK;
+  }
+  
+  return rv;
+}
+
+nsresult
+nsMsgIdentity::setIntPref(const char *prefname,
+                                 PRInt32 val)
+{
+  nsresult rv = getPrefService();
+  if (NS_FAILED(rv)) return rv;
+  
+  char *prefName = getPrefName(m_identityKey, prefname);
+  rv = m_prefs->SetIntPref(prefName, val);
+  PR_Free(prefName);
+  return rv;
+}
+
+nsresult
+nsMsgIdentity::SetKey(const char* identityKey)
+{
+  PR_FREEIF(m_identityKey);
+  m_identityKey = PL_strdup(identityKey);
+  return NS_OK;
+}
+
+nsresult
+nsMsgIdentity::GetIdentityName(char **idName) {
+  if (!idName) return NS_ERROR_NULL_POINTER;
+
+  *idName = nsnull;
+  nsresult rv = getCharPref("identityName",idName);
+  if (NS_FAILED(rv)) return rv;
+
+  // there's probably a better way of doing this
+  // thats unicode friendly?
+  if (!(*idName)) {
+    nsXPIDLCString fullName;
+    rv = GetFullName(getter_Copies(fullName));
+    if (NS_FAILED(rv)) return rv;
+    
+    nsXPIDLCString email;
+    rv = GetEmail(getter_Copies(email));
+    if (NS_FAILED(rv)) return rv;
+    
+    *idName = PR_smprintf("%s <%s>", (const char*)fullName,
+                          (const char*)email);
+    rv = NS_OK;
+  }
+
+  return rv;
+}
+
+nsresult nsMsgIdentity::SetIdentityName(const char *idName) {
+  return setCharPref("identityName", idName);
+}
+
+NS_IMETHODIMP
+nsMsgIdentity::ToString(PRUnichar **aResult)
+{
+  nsString idname("[nsIMsgIdentity: ");
+  idname += m_identityKey;
+  idname += "]";
+
+  *aResult = idname.ToNewUnicode();
+  return NS_OK;
+}
+
+/* Identity attribute accessors */
+
+// XXX - these are a COM objects, use NS_ADDREF
+//NS_IMPL_GETSET(nsMsgIdentity, Signature, nsIMsgSignature*, m_signature);
+NS_IMETHODIMP
+nsMsgIdentity::GetSignature(nsIFileSpec **sig) {
+  nsresult rv = getPrefService();
+  if (NS_FAILED(rv)) return rv;
+  
+  char *prefName = getPrefName(m_identityKey, "sig_file");
+  rv = m_prefs->GetFilePref(prefName, sig);
+  if (NS_FAILED(rv))
+    *sig = nsnull;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgIdentity::SetSignature(nsIFileSpec *sig)
+{
+
+  nsresult rv = getPrefService();
+  if (NS_FAILED(rv)) return rv;
+  
+  rv = NS_OK;
+  char *prefName = getPrefName(m_identityKey, "sig_file");
+  if (sig) 
+    rv = m_prefs->SetFilePref(NS_CONST_CAST(const char*,prefName), sig,
+                              PR_FALSE);
+  /*
+  else
+    m_prefs->ClearFilePref(prefName);
+  */
+  PR_Free(prefName);
+  return rv;
+  
+  return NS_OK;
+}
+
+NS_IMPL_GETSET(nsMsgIdentity, VCard, nsIMsgVCard*, m_vCard);
+  
+NS_IMPL_GETTER_STR(nsMsgIdentity::GetKey, m_identityKey);
+
+NS_IMPL_IDPREF_STR(FullName, "fullName");
+NS_IMPL_IDPREF_STR(Email, "useremail");
+NS_IMPL_IDPREF_STR(ReplyTo, "reply_to");
+NS_IMPL_IDPREF_STR(Organization, "organization");
+NS_IMPL_IDPREF_BOOL(ComposeHtml, "compose_html");
+NS_IMPL_IDPREF_BOOL(AttachVCard, "attach_vcard");
+NS_IMPL_IDPREF_BOOL(AttachSignature, "attach_signature");
+
+NS_IMPL_IDPREF_BOOL(DoFcc, "fcc");
+NS_IMPL_IDPREF_STR(FccFolder, "fcc_folder");
+
+NS_IMPL_IDPREF_BOOL(BccSelf, "bcc_self");
+NS_IMPL_IDPREF_BOOL(BccOthers, "bcc_other");
+NS_IMPL_IDPREF_STR (BccList, "bcc_other_list");
+
+NS_IMPL_IDPREF_STR (DraftFolder, "draft_folder");
+NS_IMPL_IDPREF_STR (StationaryFolder, "stationary_folder");
+NS_IMPL_IDPREF_STR (JunkMailFolder, "spam_folder");
+
+

mozilla/mailnews/base/util/nsMsgIdentity.h

@@ -0,0 +1,110 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef nsMsgIdentity_h___
+#define nsMsgIdentity_h___
+
+#include "nsIMsgIdentity.h"
+#include "nsIPref.h"
+#include "msgCore.h"
+
+///////////////////////////////////////////////////////////////////////////////////
+// an identity is an object designed to encapsulate all the information we need 
+// to know about a user identity. I expect this interface to grow and change a lot
+// as we flesh out our thoughts on multiple identities and what properties go into
+// these identities.
+//////////////////////////////////////////////////////////////////////////////////
+
+
+class NS_MSG_BASE nsMsgIdentity : public nsIMsgIdentity,
+                                  public nsIShutdownListener
+{
+public:
+  nsMsgIdentity();
+  virtual ~nsMsgIdentity();
+  
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGIDENTITY
+
+  // nsIShutdownListener
+  
+  NS_IMETHOD OnShutdown(const nsCID& aClass, nsISupports *service);
+  
+private:
+  nsIMsgSignature* m_signature;
+  nsIMsgVCard* m_vCard;
+  char *m_identityKey;
+  nsIPref *m_prefs;
+
+protected:
+  nsresult getPrefService();
+  char *getPrefName(const char *identityKey, const char *pref);
+  char *getDefaultPrefName(const char *pref);
+  nsresult getCharPref(const char *pref, char **);
+  nsresult getDefaultCharPref(const char *pref, char **);
+  nsresult setCharPref(const char *pref, const char *);
+
+  nsresult getBoolPref(const char *pref, PRBool *);
+  nsresult getDefaultBoolPref(const char *pref, PRBool *);
+  nsresult setBoolPref(const char *pref, PRBool);
+
+  nsresult getIntPref(const char *pref, PRInt32 *);
+  nsresult getDefaultIntPref(const char *pref, PRInt32 *);
+  nsresult setIntPref(const char *pref, PRInt32);
+
+};
+
+
+#define NS_IMPL_IDPREF_STR(_postfix, _prefname)	\
+NS_IMETHODIMP								   	\
+nsMsgIdentity::Get##_postfix(char **retval)   	\
+{											   	\
+  return getCharPref(_prefname, retval);		\
+}												\
+NS_IMETHODIMP	   								\
+nsMsgIdentity::Set##_postfix(const char *value)		\
+{												\
+  return setCharPref(_prefname, value);\
+}
+
+#define NS_IMPL_IDPREF_BOOL(_postfix, _prefname)\
+NS_IMETHODIMP								   	\
+nsMsgIdentity::Get##_postfix(PRBool *retval)   	\
+{											   	\
+  return getBoolPref(_prefname, retval);		\
+}												\
+NS_IMETHODIMP	   								\
+nsMsgIdentity::Set##_postfix(PRBool value)		\
+{												\
+  return setBoolPref(_prefname, value);			\
+}
+
+#define NS_IMPL_IDPREF_INT(_postfix, _prefname) \
+NS_IMETHODIMP								   	\
+nsMsgIdentity::Get##_postfix(PRInt32 *retval)   \
+{											   	\
+  return getIntPref(_prefname, retval);		\
+}												\
+NS_IMETHODIMP	   								\
+nsMsgIdentity::Set##_postfix(PRInt32 value)		\
+{												\
+  return setIntPref(_prefname, value);			\
+}
+
+
+#endif /* nsMsgIdentity_h___ */

mozilla/mailnews/base/util/nsMsgIncomingServer.cpp

@@ -0,0 +1,603 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "nsMsgIncomingServer.h"
+#include "nscore.h"
+#include "nsCom.h"
+#include "plstr.h"
+#include "prmem.h"
+#include "prprf.h"
+
+#include "nsIServiceManager.h"
+#include "nsIPref.h"
+#include "nsCOMPtr.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgFolderCache.h"
+#include "nsIMsgFolderCacheElement.h"
+#include "nsINetSupportDialogService.h"
+#include "nsIPrompt.h"
+#include "nsXPIDLString.h"
+#include "nsIRDFService.h"
+#include "nsIMsgProtocolInfo.h"
+#include "nsRDFCID.h"
+
+static NS_DEFINE_CID(kPrefServiceCID, NS_PREF_CID);
+static NS_DEFINE_CID(kNetSupportDialogCID, NS_NETSUPPORTDIALOG_CID);
+static NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
+
+MOZ_DECL_CTOR_COUNTER(nsMsgIncomingServer);
+
+nsMsgIncomingServer::nsMsgIncomingServer():
+    m_prefs(0),
+    m_serverKey(0),
+    m_rootFolder(0)
+{
+  MOZ_COUNT_CTOR(nsMsgIncomingServer);
+
+  NS_INIT_REFCNT();
+  m_serverBusy = PR_FALSE;
+  m_password = "";
+}
+
+nsMsgIncomingServer::~nsMsgIncomingServer()
+{
+	
+	MOZ_COUNT_DTOR(nsMsgIncomingServer);
+
+    if (m_prefs) nsServiceManager::ReleaseService(kPrefServiceCID,
+                                                  m_prefs,
+                                                  nsnull);
+    PR_FREEIF(m_serverKey)
+}
+
+NS_IMPL_ISUPPORTS1(nsMsgIncomingServer, nsIMsgIncomingServer)
+
+NS_IMPL_GETSET(nsMsgIncomingServer, ServerBusy, PRBool, m_serverBusy)
+NS_IMPL_GETTER_STR(nsMsgIncomingServer::GetKey, m_serverKey)
+
+
+NS_IMETHODIMP
+nsMsgIncomingServer::SetKey(const char * serverKey)
+{
+    nsresult rv = NS_OK;
+    // in order to actually make use of the key, we need the prefs
+    if (!m_prefs)
+        rv = nsServiceManager::GetService(kPrefServiceCID,
+                                          nsCOMTypeInfo<nsIPref>::GetIID(),
+                                          (nsISupports**)&m_prefs);
+
+    PR_FREEIF(m_serverKey);
+    m_serverKey = PL_strdup(serverKey);
+    return rv;
+}
+    
+NS_IMETHODIMP
+nsMsgIncomingServer::SetRootFolder(nsIFolder * aRootFolder)
+{
+	m_rootFolder = aRootFolder;
+	return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgIncomingServer::GetRootFolder(nsIFolder * *aRootFolder)
+{
+	if (!aRootFolder)
+		return NS_ERROR_NULL_POINTER;
+    if (m_rootFolder) {
+      *aRootFolder = m_rootFolder;
+      NS_ADDREF(*aRootFolder);
+    } else {
+      nsresult rv = CreateRootFolder();
+      if (NS_FAILED(rv)) return rv;
+      
+      *aRootFolder = m_rootFolder;
+      NS_IF_ADDREF(*aRootFolder);
+    }
+	return NS_OK;
+}
+  
+NS_IMETHODIMP
+nsMsgIncomingServer::PerformBiff()
+{
+	//This had to be implemented in the derived class, but in case someone doesn't implement it
+	//just return not implemented.
+	return NS_ERROR_NOT_IMPLEMENTED;	
+}
+
+NS_IMETHODIMP nsMsgIncomingServer::WriteToFolderCache(nsIMsgFolderCache *folderCache)
+{
+	nsresult rv = NS_OK;
+	if (m_rootFolder)
+	{
+		nsCOMPtr <nsIMsgFolder> msgFolder = do_QueryInterface(m_rootFolder, &rv);
+		if (NS_SUCCEEDED(rv) && msgFolder)
+			rv = msgFolder->WriteToFolderCache(folderCache);
+	}
+	return rv;
+}
+
+NS_IMETHODIMP
+nsMsgIncomingServer::CloseCachedConnections()
+{
+	// derived class should override if they cache connections.
+	return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMsgIncomingServer::GetServerURI(char **)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+nsresult
+nsMsgIncomingServer::CreateRootFolder()
+{
+	nsresult rv;
+			  // get the URI from the incoming server
+  nsXPIDLCString serverUri;
+  rv = GetServerURI(getter_Copies(serverUri));
+  if (NS_FAILED(rv)) return rv;
+
+  NS_WITH_SERVICE(nsIRDFService, rdf,
+                        kRDFServiceCID, &rv);
+
+  // get the corresponding RDF resource
+  // RDF will create the server resource if it doesn't already exist
+  nsCOMPtr<nsIRDFResource> serverResource;
+  rv = rdf->GetResource(serverUri, getter_AddRefs(serverResource));
+  if (NS_FAILED(rv)) return rv;
+
+  // make incoming server know about its root server folder so we 
+  // can find sub-folders given an incoming server.
+  m_rootFolder = do_QueryInterface(serverResource, &rv);
+  return rv;
+}
+
+char *
+nsMsgIncomingServer::getPrefName(const char *serverKey,
+                                 const char *fullPrefName)
+{
+  return PR_smprintf("mail.server.%s.%s", serverKey, fullPrefName);
+}
+
+// this will be slightly faster than the above, and allows
+// the "default" server preference root to be set in one place
+char *
+nsMsgIncomingServer::getDefaultPrefName(const char *fullPrefName)
+{
+  return PR_smprintf("mail.server.default.%s", fullPrefName);
+}
+
+
+nsresult
+nsMsgIncomingServer::GetBoolValue(const char *prefname,
+                                 PRBool *val)
+{
+  char *fullPrefName = getPrefName(m_serverKey, prefname);
+  nsresult rv = m_prefs->GetBoolPref(fullPrefName, val);
+  PR_Free(fullPrefName);
+  
+  if (NS_FAILED(rv))
+    rv = getDefaultBoolPref(prefname, val);
+  
+  return rv;
+}
+
+nsresult
+nsMsgIncomingServer::getDefaultBoolPref(const char *prefname,
+                                        PRBool *val) {
+  
+  char *fullPrefName = getDefaultPrefName(prefname);
+  nsresult rv = m_prefs->GetBoolPref(fullPrefName, val);
+  PR_Free(fullPrefName);
+
+  if (NS_FAILED(rv)) {
+    *val = PR_FALSE;
+    rv = NS_OK;
+  }
+  return rv;
+}
+
+nsresult
+nsMsgIncomingServer::SetBoolValue(const char *prefname,
+                                 PRBool val)
+{
+  nsresult rv;
+  char *fullPrefName = getPrefName(m_serverKey, prefname);
+
+  PRBool defaultValue;
+  rv = getDefaultBoolPref(prefname, &defaultValue);
+
+  if (NS_SUCCEEDED(rv) &&
+      val == defaultValue)
+    m_prefs->ClearUserPref(fullPrefName);
+  else
+    rv = m_prefs->SetBoolPref(fullPrefName, val);
+  
+  PR_Free(fullPrefName);
+  
+  return rv;
+}
+
+nsresult
+nsMsgIncomingServer::GetIntValue(const char *prefname,
+                                PRInt32 *val)
+{
+  char *fullPrefName = getPrefName(m_serverKey, prefname);
+  nsresult rv = m_prefs->GetIntPref(fullPrefName, val);
+  PR_Free(fullPrefName);
+
+  if (NS_FAILED(rv))
+    rv = getDefaultIntPref(prefname, val);
+  
+  return rv;
+}
+
+nsresult
+nsMsgIncomingServer::GetFileValue(const char* prefname,
+                                  nsIFileSpec **spec)
+{
+  char *fullPrefName = getPrefName(m_serverKey, prefname);
+  nsresult rv = m_prefs->GetFilePref(fullPrefName, spec);
+  PR_Free(fullPrefName);
+
+  return rv;
+}
+
+nsresult
+nsMsgIncomingServer::SetFileValue(const char* prefname,
+                                    nsIFileSpec *spec)
+{
+  char *fullPrefName = getPrefName(m_serverKey, prefname);
+  nsresult rv = m_prefs->SetFilePref(fullPrefName, spec, PR_FALSE);
+  PR_Free(fullPrefName);
+
+  return rv;
+}
+
+nsresult
+nsMsgIncomingServer::getDefaultIntPref(const char *prefname,
+                                        PRInt32 *val) {
+  
+  char *fullPrefName = getDefaultPrefName(prefname);
+  nsresult rv = m_prefs->GetIntPref(fullPrefName, val);
+  PR_Free(fullPrefName);
+
+  if (NS_FAILED(rv)) {
+    *val = 0;
+    rv = NS_OK;
+  }
+  
+  return rv;
+}
+
+nsresult
+nsMsgIncomingServer::SetIntValue(const char *prefname,
+                                 PRInt32 val)
+{
+  nsresult rv;
+  char *fullPrefName = getPrefName(m_serverKey, prefname);
+  
+  PRInt32 defaultVal;
+  rv = getDefaultIntPref(prefname, &defaultVal);
+  
+  if (NS_SUCCEEDED(rv) && defaultVal == val)
+    m_prefs->ClearUserPref(fullPrefName);
+  else
+    rv = m_prefs->SetIntPref(fullPrefName, val);
+  
+  PR_Free(fullPrefName);
+  
+  return rv;
+}
+
+nsresult
+nsMsgIncomingServer::GetCharValue(const char *prefname,
+                                 char  **val)
+{
+  char *fullPrefName = getPrefName(m_serverKey, prefname);
+  nsresult rv = m_prefs->CopyCharPref(fullPrefName, val);
+  PR_Free(fullPrefName);
+  
+  if (NS_FAILED(rv))
+    rv = getDefaultCharPref(prefname, val);
+  
+  return rv;
+}
+
+nsresult
+nsMsgIncomingServer::getDefaultCharPref(const char *prefname,
+                                        char **val) {
+  
+  char *fullPrefName = getDefaultPrefName(prefname);
+  nsresult rv = m_prefs->CopyCharPref(fullPrefName, val);
+  PR_Free(fullPrefName);
+
+  if (NS_FAILED(rv)) {
+    *val = nsnull;              // null is ok to return here
+    rv = NS_OK;
+  }
+  return rv;
+}
+
+nsresult
+nsMsgIncomingServer::SetCharValue(const char *prefname,
+                                 const char * val)
+{
+  nsresult rv;
+  char *fullPrefName = getPrefName(m_serverKey, prefname);
+
+  if (!val) {
+    m_prefs->ClearUserPref(fullPrefName);
+    return NS_OK;
+  }
+  
+  char *defaultVal=nsnull;
+  rv = getDefaultCharPref(prefname, &defaultVal);
+  
+  if (NS_SUCCEEDED(rv) &&
+      PL_strcmp(defaultVal, val) == 0)
+    m_prefs->ClearUserPref(fullPrefName);
+  else
+    rv = m_prefs->SetCharPref(fullPrefName, val);
+  
+  PR_FREEIF(defaultVal);
+  PR_Free(fullPrefName);
+  
+  return rv;
+}
+
+// pretty name is the display name to show to the user
+NS_IMETHODIMP
+nsMsgIncomingServer::GetPrettyName(PRUnichar **retval) {
+
+  char *val=nsnull;
+  nsresult rv = GetCharValue("name", &val);
+  if (NS_FAILED(rv)) return rv;
+
+  nsString prettyName;
+  
+  // if there's no name, then just return the hostname
+  if (val) {
+    prettyName = val;
+  } else {
+    
+    nsXPIDLCString username;
+    rv = GetUsername(getter_Copies(username));
+    if (NS_FAILED(rv)) return rv;
+    if ((const char*)username &&
+        PL_strcmp((const char*)username, "")!=0) {
+      prettyName = username;
+      prettyName += " on ";
+    }
+    
+    nsXPIDLCString hostname;
+    rv = GetHostName(getter_Copies(hostname));
+    if (NS_FAILED(rv)) return rv;
+
+
+    prettyName += hostname;
+  }
+
+  *retval = prettyName.ToNewUnicode();
+  
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgIncomingServer::SetPrettyName(const PRUnichar *value) {
+  // this is lossy. Not sure what to do.
+  nsCString str(value);
+  return SetCharValue("name", str.GetBuffer());
+}
+
+NS_IMETHODIMP
+nsMsgIncomingServer::ToString(PRUnichar** aResult) {
+  nsString servername("[nsIMsgIncomingServer: ");
+  servername += m_serverKey;
+  servername += "]";
+  
+  *aResult = servername.ToNewUnicode();
+  NS_ASSERTION(*aResult, "no server name!");
+  return NS_OK;
+}
+  
+
+NS_IMETHODIMP nsMsgIncomingServer::SetPassword(const char * aPassword)
+{
+	// if remember password is turned on, write the password to preferences
+	// otherwise, just set the password so we remember it for the rest of the current
+	// session.
+
+	PRBool rememberPassword = PR_FALSE;
+	GetRememberPassword(&rememberPassword);
+	
+	if (rememberPassword)
+	{
+		SetPrefPassword((char *) aPassword);
+	}
+
+	m_password = aPassword;
+
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgIncomingServer::GetPassword(char ** aPassword)
+{
+	nsresult rv = NS_OK;
+	PRBool rememberPassword = PR_FALSE;
+	// okay, here's the scoop for this messs...
+	// (1) if we have a password already, go ahead and use it!
+	// (2) if remember password is turned on, try reading in from the prefs and if we have one, go ahead
+	//	   and use it
+	// (3) otherwise prompt the user for a password and then remember that password in the server
+
+	if (m_password.IsEmpty())
+	{
+
+		// case (2)
+		GetRememberPassword(&rememberPassword);
+		if (rememberPassword)
+		{
+			nsXPIDLCString password;
+			GetPrefPassword(getter_Copies(password));
+			m_password = password;
+		}
+	}
+    
+	*aPassword = m_password.ToNewCString();
+    return rv;
+}
+
+NS_IMETHODIMP
+nsMsgIncomingServer::GetPasswordWithUI(const PRUnichar * aPromptMessage, char **aPassword) 
+{
+
+    nsXPIDLCString prefvalue;
+    GetPassword(getter_Copies(prefvalue));
+
+    nsresult rv = NS_OK;
+    if (m_password.IsEmpty()) {
+		// prompt the user for the password
+		NS_WITH_SERVICE(nsIPrompt, dialog, kNetSupportDialogCID, &rv);
+		if (NS_SUCCEEDED(rv))
+		{
+			PRUnichar * uniPassword;
+			PRBool okayValue = PR_TRUE;
+			dialog->PromptPassword(aPromptMessage, &uniPassword, &okayValue);
+				
+			if (!okayValue) // if the user pressed cancel, just return NULL;
+			{
+				*aPassword = nsnull;
+				return rv;
+			}
+
+			// we got a password back...so remember it
+			nsCString aCStr(uniPassword); 
+
+			SetPassword((const char *) aCStr);
+		} // if we got a prompt dialog
+	} // if the password is empty
+
+	*aPassword = m_password.ToNewCString();
+	return rv;
+}
+
+NS_IMETHODIMP
+nsMsgIncomingServer::SetDefaultLocalPath(nsIFileSpec *aDefaultLocalPath)
+{
+    nsresult rv;
+    nsXPIDLCString type;
+    GetType(getter_Copies(type));
+
+    nsCAutoString progid(NS_MSGPROTOCOLINFO_PROGID_PREFIX);
+    progid += type;
+
+    NS_WITH_SERVICE(nsIMsgProtocolInfo, protocolInfo, progid, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    rv = protocolInfo->SetDefaultLocalPath(aDefaultLocalPath);
+    return rv;
+}
+
+NS_IMETHODIMP
+nsMsgIncomingServer::GetLocalPath(nsIFileSpec **aLocalPath)
+{
+    nsresult rv;
+
+    // if the local path has already been set, use it
+    rv = GetFileValue("directory", aLocalPath);
+    if (NS_SUCCEEDED(rv) && *aLocalPath) return rv;
+    
+    // otherwise, create the path using.  note we are using the
+    // server key instead of the hostname
+    //
+    // TODO:  handle the case where they migrated a server of hostname "server4"
+    // and we create a server (with the account wizard) with key "server4"
+    // we'd get a collision.
+    // need to modify the code that creates keys to check for disk collision
+    nsXPIDLCString type;
+    GetType(getter_Copies(type));
+
+    nsCAutoString progid(NS_MSGPROTOCOLINFO_PROGID_PREFIX);
+    progid += type;
+
+    NS_WITH_SERVICE(nsIMsgProtocolInfo, protocolInfo, progid, &rv);
+    if (NS_FAILED(rv)) return rv;
+    
+    nsCOMPtr<nsIFileSpec> path;
+    rv = protocolInfo->GetDefaultLocalPath(getter_AddRefs(path));
+    if (NS_FAILED(rv)) return rv;
+    
+    path->CreateDir();
+    
+    nsXPIDLCString key;
+    rv = GetKey(getter_Copies(key));
+    if (NS_FAILED(rv)) return rv;
+    rv = path->AppendRelativeUnixPath(key);
+    if (NS_FAILED(rv)) return rv;
+    rv = SetLocalPath(path);
+    if (NS_FAILED(rv)) return rv;
+
+    *aLocalPath = path;
+    NS_ADDREF(*aLocalPath);
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgIncomingServer::SetLocalPath(nsIFileSpec *spec)
+{
+    if (spec) {
+        spec->CreateDir();
+        return SetFileValue("directory", spec);
+    }
+    else {
+        return NS_ERROR_NULL_POINTER;
+    }
+}
+
+NS_IMETHODIMP
+nsMsgIncomingServer::SetRememberPassword(PRBool value)
+{
+    if (value)
+        SetPrefPassword(m_password);
+    else
+        SetPrefPassword(nsnull);
+    return SetBoolValue("remember_password", value);
+}
+
+NS_IMETHODIMP
+nsMsgIncomingServer::GetRememberPassword(PRBool* value)
+{
+    return GetBoolValue("remember_password", value);
+}
+
+// use the convenience macros to implement the accessors
+NS_IMPL_SERVERPREF_STR(nsMsgIncomingServer, HostName, "hostname");
+NS_IMPL_SERVERPREF_STR(nsMsgIncomingServer, Username, "userName");
+NS_IMPL_SERVERPREF_STR(nsMsgIncomingServer, PrefPassword, "password");
+NS_IMPL_SERVERPREF_BOOL(nsMsgIncomingServer, DoBiff, "check_new_mail");
+NS_IMPL_SERVERPREF_INT(nsMsgIncomingServer, BiffMinutes, "check_time");
+NS_IMPL_SERVERPREF_STR(nsMsgIncomingServer, Type, "type");
+
+/* what was this called in 4.x? */
+// pref("mail.pop3_gets_new_mail",				true);
+
+NS_IMPL_SERVERPREF_BOOL(nsMsgIncomingServer, DownloadOnBiff, "download_on_biff");

mozilla/mailnews/base/util/nsMsgIncomingServer.h

@@ -0,0 +1,70 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef nsMsgIncomingServer_h__
+#define nsMsgIncomingServer_h__
+
+#include "nsIMsgIncomingServer.h"
+#include "nsIPref.h"
+#include "msgCore.h"
+#include "nsIFolder.h"
+#include "nsCOMPtr.h"
+
+class nsIMsgFolderCache;
+
+/*
+ * base class for nsIMsgIncomingServer - derive your class from here
+ * if you want to get some free implementation
+ * 
+ * this particular implementation is not meant to be used directly.
+ */
+
+class NS_MSG_BASE nsMsgIncomingServer : public nsIMsgIncomingServer {
+ public:
+  nsMsgIncomingServer();
+  virtual ~nsMsgIncomingServer();
+
+  NS_DECL_ISUPPORTS
+
+  NS_DECL_NSIMSGINCOMINGSERVER
+  
+private:
+  nsIPref *m_prefs;
+  char *m_serverKey;
+  nsCString m_password;
+  PRBool m_serverBusy;
+
+protected:
+  char *getPrefName(const char *serverKey, const char *pref);
+  char *getDefaultPrefName(const char *pref);
+
+  // these are private pref getters and setters for the password
+  // field. Callers should be using Get/Set Password
+  NS_IMETHOD GetPrefPassword(char * *aPassword);
+  NS_IMETHOD SetPrefPassword(const char * aPassword);
+  
+  nsCOMPtr <nsIFolder> m_rootFolder;
+  nsresult getDefaultCharPref(const char *pref, char **);
+  nsresult getDefaultBoolPref(const char *pref, PRBool *);
+  nsresult getDefaultIntPref(const char *pref, PRInt32 *);
+  
+  nsresult CreateRootFolder();
+
+};
+
+#endif // nsMsgIncomingServer_h__

mozilla/mailnews/base/util/nsMsgKeySet.h

@@ -0,0 +1,115 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _nsMsgKeySet_H_
+#define _nsMsgKeySet_H_
+
+#include "msgCore.h"
+
+// nsMsgKeySet represents a set of articles.  Typically, it is the set of
+// read articles from a .newsrc file, but it can be used for other purposes
+// too.
+
+#if 0
+// If a MSG_NewsHost* is supplied to the creation routine, then that
+// MSG_NewsHost will be notified whenever a change is made to set.
+class MSG_NewsHost;
+#endif
+
+class NS_MSG_BASE nsMsgKeySet {
+public:
+  // Creates an empty set.
+  static nsMsgKeySet* Create(/* MSG_NewsHost* host = NULL*/);
+
+  // Creates a set from the list of numbers, as might be found in a
+  // newsrc file.
+  static nsMsgKeySet* Create(const char* str/* , MSG_NewsHost* host = NULL*/);
+  ~nsMsgKeySet();
+  
+  // FirstNonMember() returns the lowest non-member of the set that is
+  // greater than 0.
+  PRInt32 FirstNonMember();
+
+  // Output() converts to a string representation suitable for writing to a
+  // .newsrc file.  (The result must be freed by the caller using delete[].)
+  char* Output();		
+
+  // IsMember() returns whether the given article is a member of this set.
+  PRBool IsMember(PRInt32 art);
+  
+  // Add() adds the given article to the set.  (Returns 1 if a change was
+  // made, 0 if it was already there, and negative on error.)
+  int Add(PRInt32 art);
+  
+  // Remove() removes the given article from the set. 
+  int Remove(PRInt32 art);
+  
+  // AddRange() adds the (inclusive) given range of articles to the set.
+  int AddRange(PRInt32 first, PRInt32 last);
+  
+  // CountMissingInRange() takes an inclusive range of articles and returns
+  // the number of articles in that range which are not in the set.
+  PRInt32 CountMissingInRange(PRInt32 start, PRInt32 end);
+  
+  // FirstMissingRange() takes an inclusive range and finds the first range
+  // of articles that are not in the set.  If none, return zeros. 
+  int FirstMissingRange(PRInt32 min, PRInt32 max, PRInt32* first, PRInt32* last);
+  
+
+  // LastMissingRange() takes an inclusive range and finds the last range
+  // of articles that are not in the set.  If none, return zeros. 
+  int LastMissingRange(PRInt32 min, PRInt32 max, PRInt32* first, PRInt32* last);
+  
+  PRInt32 GetLastMember();
+  PRInt32 GetFirstMember();
+  void  SetLastMember(PRInt32 highWaterMark);
+  // For debugging only...
+  PRInt32 getLength() {return m_length;}
+  
+#ifdef DEBUG
+  static void RunTests();
+#endif
+
+protected:
+  nsMsgKeySet(/* MSG_NewsHost* host */);
+  nsMsgKeySet(const char* /* , MSG_NewsHost* host */);
+  PRBool Grow();
+  PRBool Optimize();
+  
+#ifdef DEBUG
+  static void test_decoder(const char*);
+  static void test_adder();
+  static void test_ranges();
+  static void test_member(PRBool with_cache);
+#endif
+  
+  PRInt32 *m_data;					/* the numbers composing the `chunks' */
+  PRInt32 m_data_size;				/* size of that malloc'ed block */
+  PRInt32 m_length;				/* active area */
+  
+  PRInt32 m_cached_value;			/* a potential set member, or -1 if unset*/
+  PRInt32 m_cached_value_index;		/* the index into `data' at which a search
+									   to determine whether `cached_value' was
+									   a member of the set ended. */
+#ifdef NEWSRC_DOES_HOST_STUFF
+  MSG_NewsHost* m_host;
+#endif
+};
+
+
+#endif /* _nsMsgKeySet_H_ */

mozilla/mailnews/base/util/nsMsgLineBuffer.cpp

@@ -0,0 +1,384 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "msgCore.h"
+#include "prlog.h"
+#include "nsMsgLineBuffer.h"
+
+#include "nsIInputStream.h" // used by nsMsgLineStreamBuffer
+
+MOZ_DECL_CTOR_COUNTER(nsByteArray);
+
+nsByteArray::nsByteArray()
+{
+	MOZ_COUNT_CTOR(nsByteArray);
+	m_buffer = NULL;
+	m_bufferSize = 0;
+	m_bufferPos = 0;
+}
+
+nsByteArray::~nsByteArray()
+{
+	MOZ_COUNT_DTOR(nsByteArray);
+	PR_FREEIF(m_buffer);
+}
+
+nsresult nsByteArray::GrowBuffer(PRUint32 desired_size, PRUint32 quantum)
+{
+	if (m_bufferSize < desired_size)
+	{
+		char *new_buf;
+		PRUint32 increment = desired_size - m_bufferSize;
+		if (increment < quantum) /* always grow by a minimum of N bytes */
+			increment = quantum;
+
+
+		new_buf = (m_buffer
+				 ? (char *) PR_REALLOC (m_buffer, (m_bufferSize + increment))
+				 : (char *) PR_MALLOC (m_bufferSize + increment));
+		if (! new_buf)
+			return NS_ERROR_OUT_OF_MEMORY;
+		m_buffer = new_buf;
+		m_bufferSize += increment;
+	}
+  return 0;
+}
+
+nsresult nsByteArray::AppendString(const char *string)
+{
+	PRUint32 strLength = (string) ? PL_strlen(string) : 0;
+	return AppendBuffer(string, strLength);
+
+}
+
+nsresult nsByteArray::AppendBuffer(const char *buffer, PRUint32 length)
+{
+	nsresult ret = NS_OK;
+	if (m_bufferPos + length > m_bufferSize)
+		ret = GrowBuffer(m_bufferPos + length, 1024);
+	if (ret == NS_OK)
+	{
+		memcpy(m_buffer + m_bufferPos, buffer, length);
+		m_bufferPos += length;
+	}
+	return ret;
+}
+
+MOZ_DECL_CTOR_COUNTER(nsMsgLineBuffer);
+
+nsMsgLineBuffer::nsMsgLineBuffer(nsMsgLineBufferHandler *handler, PRBool convertNewlinesP)
+{
+	MOZ_COUNT_CTOR(nsMsgLineBuffer);
+	m_handler = handler;
+	m_convertNewlinesP = convertNewlinesP;
+    m_lookingForCRLF = PR_TRUE;
+}
+
+nsMsgLineBuffer::~nsMsgLineBuffer()
+{
+	MOZ_COUNT_DTOR(nsMsgLineBuffer);
+}
+
+void
+nsMsgLineBuffer::SetLookingForCRLF(PRBool b)
+{
+  m_lookingForCRLF = b;
+}
+
+PRInt32	nsMsgLineBuffer::BufferInput(const char *net_buffer, PRInt32 net_buffer_size)
+{
+    int status = 0;
+    if (m_bufferPos > 0 && m_buffer && m_buffer[m_bufferPos - 1] == CR &&
+        net_buffer_size > 0 && net_buffer[0] != LF) {
+        /* The last buffer ended with a CR.  The new buffer does not start
+           with a LF.  This old buffer should be shipped out and discarded. */
+        PR_ASSERT(m_bufferSize > m_bufferPos);
+        if (m_bufferSize <= m_bufferPos) return -1;
+        status = ConvertAndSendBuffer();
+        if (status < 0) 
+			return status;
+        m_bufferPos = 0;
+    }
+    while (net_buffer_size > 0)
+	{
+        const char *net_buffer_end = net_buffer + net_buffer_size;
+        const char *newline = 0;
+        const char *s;
+        
+        
+        for (s = net_buffer; s < net_buffer_end; s++)
+		{
+          if (m_lookingForCRLF) {
+            /* Move forward in the buffer until the first newline.
+               Stop when we see CRLF, CR, or LF, or the end of the buffer.
+               *But*, if we see a lone CR at the *very end* of the buffer,
+               treat this as if we had reached the end of the buffer without
+               seeing a line terminator.  This is to catch the case of the
+               buffers splitting a CRLF pair, as in "FOO\r\nBAR\r" "\nBAZ\r\n".
+            */
+            if (*s == CR || *s == LF) {
+              newline = s;
+              if (newline[0] == CR) {
+                if (s == net_buffer_end - 1) {
+                  /* CR at end - wait for the next character. */
+                  newline = 0;
+                  break;
+                }
+                else if (newline[1] == LF) {
+                  /* CRLF seen; swallow both. */
+                  newline++;
+                }
+              }
+              newline++;
+              break;
+			}
+          }
+          else {
+            /* if not looking for a CRLF, stop at CR or LF.  (for example, when parsing the newsrc file).  this fixes #9896, where we'd lose the last line of anything we'd parse that used CR as the line break. */
+            if (*s == CR || *s == LF) {
+              newline = s;
+              newline++;
+              break;
+            }
+          }
+		}
+        
+        /* Ensure room in the net_buffer and append some or all of the current
+           chunk of data to it. */
+        {
+            const char *end = (newline ? newline : net_buffer_end);
+            PRUint32 desired_size = (end - net_buffer) + m_bufferPos + 1;
+            
+            if (desired_size >= m_bufferSize)
+            {
+                status = GrowBuffer (desired_size, 1024);
+                if (status < 0) 
+					return status;
+            }
+            memcpy (m_buffer + m_bufferPos, net_buffer, (end - net_buffer));
+            m_bufferPos += (end - net_buffer);
+        }
+        
+        /* Now m_buffer contains either a complete line, or as complete
+           a line as we have read so far.
+           
+           If we have a line, process it, and then remove it from `m_buffer'.
+           Then go around the loop again, until we drain the incoming data.
+           */
+        if (!newline)
+            return 0;
+        
+        status = ConvertAndSendBuffer();
+        if (status < 0) return status;
+        
+        net_buffer_size -= (newline - net_buffer);
+        net_buffer = newline;
+        m_bufferPos = 0;
+	}
+#ifdef DEBUG_bienvenu
+	printf("returning from buffer input m_bufferPos = %ld\n", m_bufferPos);
+#endif	
+    return 0;
+}
+
+PRInt32 nsMsgLineBuffer::HandleLine(char *line, PRUint32 line_length)
+{
+	NS_ASSERTION(PR_FALSE, "must override this method if you don't provide a handler");
+	return 0;
+}
+
+PRInt32 nsMsgLineBuffer::ConvertAndSendBuffer()
+{
+    /* Convert the line terminator to the native form.
+     */
+
+	char *buf = m_buffer;
+	PRInt32 length = m_bufferPos;
+
+    char* newline;
+    
+    PR_ASSERT(buf && length > 0);
+    if (!buf || length <= 0) 
+		return -1;
+    newline = buf + length;
+    
+    PR_ASSERT(newline[-1] == CR || newline[-1] == LF);
+    if (newline[-1] != CR && newline[-1] != LF)
+		return -1;
+    
+    if (!m_convertNewlinesP)
+	{
+	}
+#if (MSG_LINEBREAK_LEN == 1)
+    else if ((newline - buf) >= 2 &&
+             newline[-2] == CR &&
+             newline[-1] == LF)
+	{
+        /* CRLF -> CR or LF */
+        buf [length - 2] = MSG_LINEBREAK[0];
+        length--;
+	}
+    else if (newline > buf + 1 &&
+             newline[-1] != MSG_LINEBREAK[0])
+	{
+        /* CR -> LF or LF -> CR */
+        buf [length - 1] = MSG_LINEBREAK[0];
+	}
+#else
+    else if (((newline - buf) >= 2 && newline[-2] != CR) ||
+             ((newline - buf) >= 1 && newline[-1] != LF))
+	{
+        /* LF -> CRLF or CR -> CRLF */
+        length++;
+        buf[length - 2] = MSG_LINEBREAK[0];
+        buf[length - 1] = MSG_LINEBREAK[1];
+	}
+#endif
+    
+    return (m_handler) ? m_handler->HandleLine(buf, length) : HandleLine(buf, length);
+}
+
+// If there's still some data (non CRLF terminated) flush it out
+PRInt32 nsMsgLineBuffer::FlushLastLine()
+{
+	char *buf = m_buffer + m_bufferPos;
+	PRInt32 length = m_bufferPos - 1;
+	if (length > 0)
+		return (m_handler) ? m_handler->HandleLine(buf, length) : HandleLine(buf, length);
+	else
+		return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// This is a utility class used to efficiently extract lines from an input stream by buffering
+// read but unprocessed stream data in a buffer. 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+nsMsgLineStreamBuffer::nsMsgLineStreamBuffer(PRUint32 aBufferSize, const char * aEndOfLineToken, 
+											 PRBool aAllocateNewLines, PRBool aEatCRLFs) 
+											: m_eatCRLFs(aEatCRLFs), m_allocateNewLines(aAllocateNewLines),
+											  m_endOfLineToken(aEndOfLineToken)
+{
+	NS_PRECONDITION(aBufferSize > 0, "invalid buffer size!!!");
+	m_dataBuffer = nsnull;
+	m_startPos = nsnull;
+
+	// used to buffer incoming data by ReadNextLineFromInput
+	if (aBufferSize > 0)
+	{
+		m_dataBuffer = (char *) PR_CALLOC(sizeof(char) * aBufferSize);
+		m_startPos = m_dataBuffer;
+	}
+
+	m_dataBufferSize = aBufferSize;
+}
+
+nsMsgLineStreamBuffer::~nsMsgLineStreamBuffer()
+{
+	PR_FREEIF(m_dataBuffer); // release our buffer...
+}
+
+// the design for this method has an inherit bug: if the length of the line is greater than the size of m_dataBufferSize, 
+// then we'll never find the next line because we can't hold the whole line in memory. 
+// aInputStream - the input stream we want to read a line from
+// aPauseForMoreData is returned as PR_TRUE if the stream does not yet contain a line and we must wait for more
+// data to come into the stream.
+
+// Note to people wishing to modify this function: Be *VERY CAREFUL* this is a critical function used by all of
+// our mail protocols including imap, nntp, and pop. If you screw it up, you could break a lot of stuff.....
+
+char * nsMsgLineStreamBuffer::ReadNextLine(nsIInputStream * aInputStream, PRUint32 &aNumBytesInLine, PRBool &aPauseForMoreData)
+{
+	// try to extract a line from m_inputBuffer. If we don't have an entire line, 
+	// then read more bytes out from the stream. If the stream is empty then wait
+	// on the monitor for more data to come in.
+
+	NS_PRECONDITION(m_startPos && m_dataBufferSize > 0, "invalid input arguments for read next line from input");
+	
+	// initialize out values
+	aPauseForMoreData = PR_FALSE;
+	aNumBytesInLine = 0;
+	char * endOfLine = nsnull;
+
+	PRUint32 numBytesInBuffer = PL_strlen(m_startPos);
+	
+	if (numBytesInBuffer > 0) // any data in our internal buffer?
+		endOfLine = PL_strstr(m_startPos, m_endOfLineToken); // see if we already have a line ending...
+
+	// it's possible that we got here before the first time we receive data from the server
+	// so aInputStream will be nsnull...
+	if (!endOfLine && aInputStream) // get some more data from the server
+	{
+		PRUint32 numBytesInStream = 0;
+		PRUint32 numBytesCopied = 0;
+		aInputStream->Available(&numBytesInStream);
+		// if the number of bytes we want to read from the stream, is greater than the number
+		// of bytes left in our buffer, then we need to shift the start pos and its contents
+		// down to the beginning of m_dataBuffer...
+		PRUint32 numFreeBytesInBuffer = (m_dataBuffer + m_dataBufferSize) - (m_startPos + numBytesInBuffer);
+		if (numBytesInStream >= numFreeBytesInBuffer)
+		{
+			nsCRT::memcpy(m_dataBuffer, m_startPos, numBytesInBuffer);
+			m_dataBuffer[numBytesInBuffer] = '\0'; // make sure the end of the buffer is terminated
+			m_startPos = m_dataBuffer; // update the new start position
+			// update the number of free bytes in the buffer
+			numFreeBytesInBuffer = m_dataBufferSize - numBytesInBuffer;
+		}
+
+		PRUint32 numBytesToCopy = PR_MIN(numFreeBytesInBuffer - 1 /* leave one for a null terminator */, numBytesInStream);
+		// read the data into the end of our data buffer
+		if (numBytesToCopy > 0)
+		{
+			aInputStream->Read(m_startPos + numBytesInBuffer, numBytesToCopy, &numBytesCopied);
+			m_startPos[numBytesInBuffer + numBytesCopied] = '\0';
+		}
+
+		// okay, now that we've tried to read in more data from the stream, look for another end of line 
+		// character 
+		endOfLine = PL_strstr(m_startPos, m_endOfLineToken);
+
+	}
+
+	// okay, now check again for endOfLine.
+	if (endOfLine)
+	{
+		if (!m_eatCRLFs)
+			endOfLine += PL_strlen(m_endOfLineToken); // count for CRLF
+
+		// PR_CALLOC zeros out the allocated line
+		char* newLine = (char*) PR_CALLOC(endOfLine-m_startPos+1);
+		if (!newLine)
+			return nsnull;
+
+		nsCRT::memcpy(newLine, m_startPos, endOfLine-m_startPos); // copy the string into the new line buffer
+		aNumBytesInLine = endOfLine - m_startPos;
+
+		if (m_eatCRLFs)
+			endOfLine += PL_strlen(m_endOfLineToken); // advance past CRLF if we haven't already done so...
+
+		// now we need to update the data buffer to go past the line we just read out. 
+		if (PL_strlen(endOfLine) <= 0) // if no more data in the buffer, then just zero out the buffer...
+			m_startPos[0] = '\0';
+		else  // advance 
+			m_startPos = endOfLine; // move us up to the end of the line
+		return newLine;
+	}
+
+	aPauseForMoreData = PR_TRUE;
+	return nsnull; // if we somehow got here. we don't have another line in the buffer yet...need to wait for more data...
+}

mozilla/mailnews/base/util/nsMsgLineBuffer.h

@@ -0,0 +1,113 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+#ifndef _nsMsgLineBuffer_H
+#define _nsMsgLineBuffer_H
+
+#include "msgCore.h"    // precompiled header...
+
+// I can't believe I have to have this stupid class, but I can't find
+// anything suitable (nsStrImpl might be, when its done). nsIByteBuffer
+// would do, if I had a stream for input, which I don't.
+
+class NS_MSG_BASE nsByteArray 
+{
+public:
+	nsByteArray();
+	virtual ~nsByteArray();
+	PRUint32	GetSize() {return m_bufferSize;}
+	PRUint32	GetBufferPos() {return m_bufferPos;}
+	nsresult	GrowBuffer(PRUint32 desired_size, PRUint32 quantum = 1024);
+	nsresult	AppendString(const char *string);
+	nsresult	AppendBuffer(const char *buffer, PRUint32 length);
+	void		ResetWritePos() {m_bufferPos = 0;}
+	char		*GetBuffer() {return m_buffer;}
+protected:
+	char		*m_buffer;
+	PRUint32	m_bufferSize;
+	PRUint32	m_bufferPos;	// write Pos in m_buffer - where the next byte should go.
+};
+
+
+class NS_MSG_BASE nsMsgLineBufferHandler : public nsByteArray
+{
+public:
+	virtual PRInt32 HandleLine(char *line, PRUint32 line_length) = 0;
+};
+
+class NS_MSG_BASE nsMsgLineBuffer : public nsByteArray
+{
+public:
+	nsMsgLineBuffer(nsMsgLineBufferHandler *handler, PRBool convertNewlinesP);
+
+	virtual ~nsMsgLineBuffer();
+	PRInt32	BufferInput(const char *net_buffer, PRInt32 net_buffer_size);
+	// Not sure why anyone cares, by NNTPHost seems to want to know the buf pos.
+	PRUint32	GetBufferPos() {return m_bufferPos;}
+
+	virtual PRInt32 HandleLine(char *line, PRUint32 line_length);
+	// flush last line, though it won't be CRLF terminated.
+	virtual PRInt32 FlushLastLine();
+protected:
+	nsMsgLineBuffer(PRBool convertNewlinesP);
+
+	PRInt32 ConvertAndSendBuffer();
+    void SetLookingForCRLF(PRBool b);
+
+	nsMsgLineBufferHandler *m_handler;
+	PRBool		m_convertNewlinesP;
+    PRBool      m_lookingForCRLF; 
+};
+
+// I'm adding this utility class here for lack of a better place. This utility class is similar to nsMsgLineBuffer
+// except it works from an input stream. It is geared towards efficiently parsing new lines out of a stream by storing
+// read but unprocessed bytes in a buffer. I envision the primary use of this to be our mail protocols such as imap, news and
+// pop which need to process line by line data being returned in the form of a proxied stream from the server.
+
+class nsIInputStream;
+
+class NS_MSG_BASE nsMsgLineStreamBuffer
+{
+public:
+	// aBufferSize -- size of the buffer you want us to use for buffering stream data
+	// aEndOfLinetoken -- The delimeter string to be used for determining the end of line. This 
+	//				      allows us to parse platform specific end of line endings by making it
+	//					  a parameter.
+	// aAllocateNewLines -- PR_TRUE if you want calls to ReadNextLine to allocate new memory for the line. 
+	//						if false, the char * returned is just a ptr into the buffer. Subsequent calls to
+	//						ReadNextLine will alter the data so your ptr only has a life time of a per call.
+	// aEatCRLFs  -- PR_TRUE if you don't want to see the CRLFs on the lines returned by ReadNextLine. 
+	//				 PR_FALSE if you do want to see them.
+	nsMsgLineStreamBuffer(PRUint32 aBufferSize, const char * aEndOfLineToken, PRBool aAllocateNewLines, PRBool aEatCRLFs = PR_TRUE); // specify the size of the buffer you want the class to use....
+	virtual ~nsMsgLineStreamBuffer();
+
+	// Caller must free the line returned using PR_Free
+	// aEndOfLinetoken -- delimeter used to denote the end of a line.
+	// aNumBytesInLine -- The number of bytes in the line returned
+	// aPauseForMoreData -- There is not enough data in the stream to make a line at this time...
+	char * ReadNextLine(nsIInputStream * aInputStream, PRUint32 &anumBytesInLine, PRBool &aPauseForMoreData);
+protected:
+	PRBool m_eatCRLFs;
+	PRBool m_allocateNewLines;
+	char * m_dataBuffer;
+	char * m_startPos;
+	const char * m_endOfLineToken;
+	PRUint32 m_dataBufferSize;
+};
+
+
+#endif

mozilla/mailnews/base/util/nsMsgMailNewsUrl.cpp

@@ -0,0 +1,399 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "msgCore.h"
+#include "nsMsgMailNewsUrl.h"
+#include "nsMsgBaseCID.h"
+#include "nsIMsgMailSession.h"
+#include "nsXPIDLString.h"
+
+static NS_DEFINE_CID(kUrlListenerManagerCID, NS_URLLISTENERMANAGER_CID);
+static NS_DEFINE_CID(kStandardUrlCID, NS_STANDARDURL_CID);
+static NS_DEFINE_CID(kMsgMailSessionCID, NS_MSGMAILSESSION_CID);
+
+nsMsgMailNewsUrl::nsMsgMailNewsUrl()
+{
+    NS_INIT_REFCNT();
+ 
+	// nsIURI specific state
+	m_errorMessage = nsnull;
+	m_runningUrl = PR_FALSE;
+	m_updatingFolder = PR_FALSE;
+
+	nsComponentManager::CreateInstance(kUrlListenerManagerCID, nsnull, nsCOMTypeInfo<nsIUrlListenerManager>::GetIID(), (void **) getter_AddRefs(m_urlListeners));
+	nsComponentManager::CreateInstance(kStandardUrlCID, nsnull, nsCOMTypeInfo<nsIURL>::GetIID(), (void **) getter_AddRefs(m_baseURL));
+}
+ 
+nsMsgMailNewsUrl::~nsMsgMailNewsUrl()
+{
+	PR_FREEIF(m_errorMessage);
+}
+  
+NS_IMPL_ADDREF(nsMsgMailNewsUrl);
+NS_IMPL_RELEASE(nsMsgMailNewsUrl);
+
+nsresult nsMsgMailNewsUrl::QueryInterface(const nsIID &aIID, void** aInstancePtr)
+{
+    if (NULL == aInstancePtr) {
+        return NS_ERROR_NULL_POINTER;
+    }
+    if (aIID.Equals(nsCOMTypeInfo<nsIURI>::GetIID())) {
+        *aInstancePtr = (void*) ((nsIURI*)this);
+        NS_ADDREF_THIS();
+        return NS_OK;
+    }
+	if (aIID.Equals(nsCOMTypeInfo<nsIURL>::GetIID())) {
+        *aInstancePtr = (void*) ((nsIURL*)this);
+        NS_ADDREF_THIS();
+        return NS_OK;
+    }
+	if (aIID.Equals(nsCOMTypeInfo<nsIMsgMailNewsUrl>::GetIID()))
+	{
+		*aInstancePtr = (void *) ((nsIMsgMailNewsUrl*) this);
+		NS_ADDREF_THIS();
+		return NS_OK;
+	}
+ 
+	if (aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID()))    
+	{
+		*aInstancePtr = (void *) ((nsIMsgMailNewsUrl*) this);
+		NS_ADDREF_THIS();
+		return NS_OK;
+	}
+#if defined(NS_DEBUG)
+    /*
+     * Check for the debug-only interface indicating thread-safety
+     */
+    static NS_DEFINE_IID(kIsThreadsafeIID, NS_ISTHREADSAFE_IID);
+    if (aIID.Equals(kIsThreadsafeIID)) {
+        return NS_OK;
+    }
+#endif
+    return NS_NOINTERFACE;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Begin nsIMsgMailNewsUrl specific support
+////////////////////////////////////////////////////////////////////////////////////
+
+nsresult nsMsgMailNewsUrl::GetUrlState(PRBool * aRunningUrl)
+{
+	if (aRunningUrl)
+		*aRunningUrl = m_runningUrl;
+
+	return NS_OK;
+}
+
+nsresult nsMsgMailNewsUrl::SetUrlState(PRBool aRunningUrl, nsresult aExitCode)
+{
+	m_runningUrl = aRunningUrl;
+	nsCOMPtr <nsIMsgStatusFeedback> statusFeedback;
+
+	if (NS_SUCCEEDED(GetStatusFeedback(getter_AddRefs(statusFeedback))) && statusFeedback)
+	{
+		if (m_runningUrl)
+			statusFeedback->StartMeteors();
+		else
+		{
+			statusFeedback->ShowProgress(0);
+			statusFeedback->StopMeteors();
+		}
+	}
+	if (m_urlListeners)
+	{
+		if (m_runningUrl)
+		{
+			m_urlListeners->OnStartRunningUrl(this);
+		}
+		else
+		{
+			m_urlListeners->OnStopRunningUrl(this, aExitCode);
+		}
+	}
+
+	return NS_OK;
+}
+
+nsresult nsMsgMailNewsUrl::RegisterListener (nsIUrlListener * aUrlListener)
+{
+	if (m_urlListeners)
+		m_urlListeners->RegisterListener(aUrlListener);
+	return NS_OK;
+}
+
+nsresult nsMsgMailNewsUrl::UnRegisterListener (nsIUrlListener * aUrlListener)
+{
+	if (m_urlListeners)
+		m_urlListeners->UnRegisterListener(aUrlListener);
+	return NS_OK;
+}
+
+nsresult nsMsgMailNewsUrl::SetErrorMessage (const char * errorMessage)
+{
+	// functionality has been moved to nsIMsgStatusFeedback
+	return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+nsresult nsMsgMailNewsUrl::GetErrorMessage (char ** errorMessage)
+{
+	// functionality has been moved to nsIMsgStatusFeedback
+	return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::GetServer(nsIMsgIncomingServer ** aIncomingServer)
+{
+	// mscott --> we could cache a copy of the server here....but if we did, we run
+	// the risk of leaking the server if any single url gets leaked....of course that
+	// shouldn't happen...but it could. so i'm going to look it up every time and
+	// we can look at caching it later.
+
+	nsXPIDLCString host;
+	nsXPIDLCString scheme;
+
+	nsresult rv = GetHost(getter_Copies(host));
+	rv = GetScheme(getter_Copies(scheme));
+    if (NS_SUCCEEDED(rv))
+    {
+        NS_WITH_SERVICE(nsIMsgMailSession, session, kMsgMailSessionCID, &rv); 
+        if (NS_FAILED(rv)) return rv;
+        
+        nsCOMPtr<nsIMsgAccountManager> accountManager;
+        rv = session->GetAccountManager(getter_AddRefs(accountManager));
+        if(NS_FAILED(rv)) return rv;
+        
+        nsCOMPtr<nsIMsgIncomingServer> server;
+        rv = accountManager->FindServer(GetUserName(),
+                                        host,
+                                        scheme,
+                                        aIncomingServer);
+    }
+
+    return rv;
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::SetStatusFeedback(nsIMsgStatusFeedback *aMsgFeedback)
+{
+	if (aMsgFeedback)
+		m_statusFeedback = do_QueryInterface(aMsgFeedback);
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::GetStatusFeedback(nsIMsgStatusFeedback **aMsgFeedback)
+{
+	nsresult rv = NS_OK;
+	// note: it is okay to return a null status feedback and not return an error
+	// it's possible the url really doesn't have status feedback
+	if (!m_statusFeedback)
+	{
+		NS_WITH_SERVICE(nsIMsgMailSession, mailSession, kMsgMailSessionCID, &rv); 
+
+		if(NS_SUCCEEDED(rv))
+			mailSession->GetTemporaryMsgStatusFeedback(getter_AddRefs(m_statusFeedback));
+	}
+	if (aMsgFeedback)
+	{
+		*aMsgFeedback = m_statusFeedback;
+		NS_IF_ADDREF(*aMsgFeedback);
+	}
+	else
+		rv = NS_ERROR_NULL_POINTER;
+	return rv;
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::GetUpdatingFolder(PRBool *aResult)
+{
+	if (!aResult)
+		return NS_ERROR_NULL_POINTER;
+	*aResult = m_updatingFolder;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::SetUpdatingFolder(PRBool updatingFolder)
+{
+	m_updatingFolder = updatingFolder;
+	return NS_OK;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////
+// End nsIMsgMailNewsUrl specific support
+////////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////////
+// Begin nsIURI support
+////////////////////////////////////////////////////////////////////////////////////
+
+
+NS_IMETHODIMP nsMsgMailNewsUrl::GetSpec(char * *aSpec)
+{
+	return m_baseURL->GetSpec(aSpec);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::SetSpec(const char * aSpec)
+{
+	return m_baseURL->SetSpec(aSpec);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::GetScheme(char * *aScheme)
+{
+	return m_baseURL->GetScheme(aScheme);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::SetScheme(const char * aScheme)
+{
+	return m_baseURL->SetScheme(aScheme);
+}
+
+
+NS_IMETHODIMP nsMsgMailNewsUrl::GetPreHost(char * *aPreHost)
+{
+	return m_baseURL->GetPreHost(aPreHost);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::SetPreHost(const char * aPreHost)
+{
+	return m_baseURL->SetPreHost(aPreHost);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::GetHost(char * *aHost)
+{
+	return m_baseURL->GetHost(aHost);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::SetHost(const char * aHost)
+{
+	return m_baseURL->SetHost(aHost);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::GetPort(PRInt32 *aPort)
+{
+	return m_baseURL->GetPort(aPort);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::SetPort(PRInt32 aPort)
+{
+	return m_baseURL->SetPort(aPort);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::GetPath(char * *aPath)
+{
+	return m_baseURL->GetPath(aPath);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::SetPath(const char * aPath)
+{
+	return m_baseURL->SetPath(aPath);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::Equals(nsIURI *other, PRBool *_retval)
+{
+	return m_baseURL->Equals(other, _retval);
+}
+
+
+NS_IMETHODIMP nsMsgMailNewsUrl::Clone(nsIURI **_retval)
+{
+	return m_baseURL->Clone(_retval);
+}	
+
+NS_IMETHODIMP nsMsgMailNewsUrl::SetRelativePath(const char *i_RelativePath)
+{
+	return m_baseURL->SetRelativePath(i_RelativePath);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::GetDirectory(char * *aDirectory)
+{
+	return m_baseURL->GetDirectory(aDirectory);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::SetDirectory(const char *aDirectory)
+{
+
+	return m_baseURL->SetDirectory(aDirectory);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::GetFileName(char * *aFileName)
+{
+	return m_baseURL->GetFileName(aFileName);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::GetFileBaseName(char * *aFileBaseName)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::SetFileBaseName(const char * aFileBaseName)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::GetFileExtension(char * *aFileExtension)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::SetFileExtension(const char * aFileExtension)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::SetFileName(const char * aFileName)
+{
+	return m_baseURL->SetFileName(aFileName);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::GetParam(char * *aParam)
+{
+	return m_baseURL->GetParam(aParam);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::SetParam(const char *aParam)
+{
+	return m_baseURL->SetParam(aParam);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::GetQuery(char * *aQuery)
+{
+	return m_baseURL->GetQuery(aQuery);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::SetQuery(const char *aQuery)
+{
+	return m_baseURL->SetQuery(aQuery);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::GetRef(char * *aRef)
+{
+	return m_baseURL->GetRef(aRef);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::SetRef(const char *aRef)
+{
+	return m_baseURL->SetRef(aRef);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::GetFilePath(char **o_DirFile)
+{
+	return m_baseURL->GetFilePath(o_DirFile);
+}
+
+NS_IMETHODIMP nsMsgMailNewsUrl::SetFilePath(const char *i_DirFile)
+{
+	return m_baseURL->SetFilePath(i_DirFile);
+}
+

mozilla/mailnews/base/util/nsMsgMailNewsUrl.h

@@ -0,0 +1,66 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef nsMsgMailNewsUrl_h___
+#define nsMsgMailNewsUrl_h___
+
+#include "nscore.h"
+#include "nsISupports.h"
+#include "nsIUrlListener.h"
+#include "nsIUrlListenerManager.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsCOMPtr.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsIURL.h"
+
+///////////////////////////////////////////////////////////////////////////////////
+// Okay, I found that all of the mail and news url interfaces needed to support
+// several common interfaces (in addition to those provided through nsIURI). 
+// So I decided to group them all in this implementation so we don't have to
+// duplicate the code.
+//
+//////////////////////////////////////////////////////////////////////////////////
+
+class NS_MSG_BASE nsMsgMailNewsUrl : public nsIMsgMailNewsUrl
+{
+public:
+	nsMsgMailNewsUrl();
+
+	NS_DECL_ISUPPORTS
+    NS_DECL_NSIMSGMAILNEWSURL
+    NS_DECL_NSIURI
+    NS_DECL_NSIURL
+
+protected:
+	virtual ~nsMsgMailNewsUrl();
+
+	// a helper function I needed from derived urls...
+	virtual const char * GetUserName() = 0;
+
+	nsCOMPtr<nsIURL> m_baseURL;
+	nsCOMPtr<nsIMsgStatusFeedback> m_statusFeedback;
+	char		*m_errorMessage;
+	PRBool		m_runningUrl;
+	PRBool		m_updatingFolder;
+
+	// manager of all of current url listeners....
+	nsCOMPtr<nsIUrlListenerManager> m_urlListeners;
+};
+
+
+#endif /* nsMsgMailNewsUrl_h___ */

mozilla/mailnews/base/util/nsMsgProtocol.cpp

@@ -0,0 +1,369 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "msgCore.h"
+#include "nsMsgProtocol.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsISocketTransportService.h"
+#include "nsXPIDLString.h"
+#include "nsSpecialSystemDirectory.h"
+#include "nsILoadGroup.h"
+#include "nsIIOService.h"
+
+static NS_DEFINE_CID(kSocketTransportServiceCID, NS_SOCKETTRANSPORTSERVICE_CID);
+static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
+
+NS_IMPL_ISUPPORTS3(nsMsgProtocol, nsIStreamListener, nsIStreamObserver, nsIChannel)
+
+nsMsgProtocol::nsMsgProtocol()
+{
+	NS_INIT_REFCNT();
+	m_flags = 0;
+	m_startPosition = 0;
+	m_readCount = 0;
+	m_socketIsOpen = PR_FALSE;
+		
+	m_tempMsgFileSpec = nsSpecialSystemDirectory(nsSpecialSystemDirectory::OS_TemporaryDirectory);
+	m_tempMsgFileSpec += "tempMessage.eml";
+}
+
+nsMsgProtocol::~nsMsgProtocol()
+{}
+
+nsresult nsMsgProtocol::OpenNetworkSocket(nsIURI * aURL) // open a connection on this url
+{
+	nsresult rv = NS_OK;
+	nsXPIDLCString hostName;
+	PRInt32 port = 0;
+
+	m_readCount = -1; // with socket connections we want to read as much data as arrives
+	m_startPosition = 0;
+
+    NS_WITH_SERVICE(nsISocketTransportService, socketService, kSocketTransportServiceCID, &rv);
+
+	if (NS_SUCCEEDED(rv) && aURL)
+	{
+		aURL->GetPort(&port);
+		aURL->GetHost(getter_Copies(hostName));
+
+		rv = socketService->CreateTransport(hostName, port, nsnull, getter_AddRefs(m_channel));
+		if (NS_SUCCEEDED(rv) && m_channel)
+		{
+			m_socketIsOpen = PR_FALSE;
+			rv = SetupTransportState();
+		}
+	}
+
+	return rv;
+}
+
+nsresult nsMsgProtocol::OpenFileSocket(nsIURI * aURL, const nsFileSpec * aFileSpec, PRUint32 aStartPosition, PRInt32 aReadCount)
+{
+	// mscott - file needs to be encoded directly into aURL. I should be able to get
+	// rid of this method completely.
+
+	nsresult rv = NS_OK;
+	m_startPosition = aStartPosition;
+	m_readCount = aReadCount;
+
+    NS_WITH_SERVICE(nsIIOService, netService, kIOServiceCID, &rv);
+	if (NS_SUCCEEDED(rv) && aURL)
+	{
+		// extract the file path from the uri...
+		nsXPIDLCString filePath;
+		aURL->GetPath(getter_Copies(filePath));
+		char * urlSpec = PR_smprintf("file://%s", (const char *) filePath);
+
+		rv = netService->NewChannel("Load", urlSpec, 
+                                    nsnull,     // null base URI
+                                    nsnull,     // null load group
+                                    nsnull,     // null eventsink getter
+                                    getter_AddRefs(m_channel));
+		PR_FREEIF(urlSpec);
+
+		if (NS_SUCCEEDED(rv) && m_channel)
+		{
+			m_socketIsOpen = PR_FALSE;
+			// rv = SetupTransportState();
+		}
+	}
+
+	return rv;
+}
+
+nsresult nsMsgProtocol::SetupTransportState()
+{
+	nsresult rv = NS_OK;
+
+	if (!m_socketIsOpen && m_channel)
+	{
+		rv = m_channel->OpenOutputStream(0 /* start position */, getter_AddRefs(m_outputStream));
+
+		NS_ASSERTION(NS_SUCCEEDED(rv), "unable to create an output stream");
+		// we want to open the stream 
+	} // if m_transport
+
+	return rv;
+}
+
+nsresult nsMsgProtocol::CloseSocket()
+{
+	// release all of our socket state
+	m_socketIsOpen = PR_FALSE;
+	m_outputStream = null_nsCOMPtr();
+	m_channel = null_nsCOMPtr();
+
+	return NS_OK;
+}
+
+/*
+ * Writes the data contained in dataBuffer into the current output stream. It also informs
+ * the transport layer that this data is now available for transmission.
+ * Returns a positive number for success, 0 for failure (not all the bytes were written to the
+ * stream, etc). We need to make another pass through this file to install an error system (mscott)
+ */
+
+PRInt32 nsMsgProtocol::SendData(nsIURI * aURL, const char * dataBuffer)
+{
+	PRUint32 writeCount = 0; 
+	PRInt32 status = 0; 
+
+//	NS_PRECONDITION(m_outputStream, "oops....we don't have an output stream...how did that happen?");
+	if (dataBuffer && m_outputStream)
+	{
+		status = m_outputStream->Write(dataBuffer, PL_strlen(dataBuffer), &writeCount);
+	}
+
+	return status;
+}
+
+// Whenever data arrives from the connection, core netlib notifices the protocol by calling
+// OnDataAvailable. We then read and process the incoming data from the input stream. 
+NS_IMETHODIMP nsMsgProtocol::OnDataAvailable(nsIChannel * /* aChannel */, nsISupports *ctxt, nsIInputStream *inStr, PRUint32 sourceOffset, PRUint32 count)
+{
+	// right now, this really just means turn around and churn through the state machine
+	nsCOMPtr<nsIURI> uri = do_QueryInterface(ctxt);
+	return ProcessProtocolState(uri, inStr, sourceOffset, count);
+}
+
+NS_IMETHODIMP nsMsgProtocol::OnStartRequest(nsIChannel * aChannel, nsISupports *ctxt)
+{
+	nsresult rv = NS_OK;
+	nsCOMPtr <nsIMsgMailNewsUrl> aMsgUrl = do_QueryInterface(ctxt, &rv);
+	if (NS_SUCCEEDED(rv) && aMsgUrl)
+		rv = aMsgUrl->SetUrlState(PR_TRUE, NS_OK);
+
+	// if we are set up as a channel, we should notify our channel listener that we are starting...
+	// so pass in ourself as the channel and not the underlying socket or file channel the protocol
+	// happens to be using
+	if (m_channelListener)
+		rv = m_channelListener->OnStartRequest(this, m_channelContext);
+
+	return rv;
+}
+
+// stop binding is a "notification" informing us that the stream associated with aURL is going away. 
+NS_IMETHODIMP nsMsgProtocol::OnStopRequest(nsIChannel * aChannel, nsISupports *ctxt, nsresult aStatus, const PRUnichar* aMsg)
+{
+	nsresult rv = NS_OK;
+	nsCOMPtr <nsIMsgMailNewsUrl> aMsgUrl = do_QueryInterface(ctxt, &rv);
+	if (NS_SUCCEEDED(rv) && aMsgUrl)
+		rv = aMsgUrl->SetUrlState(PR_FALSE, aStatus);
+
+	// if we are set up as a channel, we should notify our channel listener that we are starting...
+	// so pass in ourself as the channel and not the underlying socket or file channel the protocol
+	// happens to be using
+	if (m_channelListener)
+		rv = m_channelListener->OnStopRequest(this, m_channelContext, aStatus, aMsg);
+
+	return rv;
+}
+
+nsresult nsMsgProtocol::LoadUrl(nsIURI * aURL, nsISupports * aConsumer)
+{
+	// okay now kick us off to the next state...
+	// our first state is a process state so drive the state machine...
+	nsresult rv = NS_OK;
+	nsCOMPtr <nsIMsgMailNewsUrl> aMsgUrl = do_QueryInterface(aURL);
+
+	if (NS_SUCCEEDED(rv))
+	{
+		rv = aMsgUrl->SetUrlState(PR_TRUE, NS_OK); // set the url as a url currently being run...
+
+    // if the url is given a stream consumer then we should use it to forward calls to...
+    if (!m_channelListener && aConsumer) // if we don't have a registered listener already
+    {
+      m_channelListener = do_QueryInterface(aConsumer);
+      if (!m_channelContext)
+        m_channelContext = do_QueryInterface(aURL);
+    }
+
+		if (!m_socketIsOpen)
+		{
+			nsCOMPtr<nsISupports> urlSupports = do_QueryInterface(aURL);
+
+			// put us in a state where we are always notified of incoming data
+			m_channel->AsyncRead(m_startPosition, m_readCount, urlSupports ,this /* stream observer */);
+			m_socketIsOpen = PR_TRUE; // mark the channel as open
+		} // if we got an event queue service
+		else  // the connection is already open so we should begin processing our new url...
+			rv = ProcessProtocolState(aURL, nsnull, 0, 0); 
+	}
+
+	return rv;
+}
+
+///////////////////////////////////////////////////////////////////////
+// The rest of this file is mostly nsIChannel mumbo jumbo stuff
+///////////////////////////////////////////////////////////////////////
+
+nsresult nsMsgProtocol::SetUrl(nsIURI * aURL)
+{
+	m_url = dont_QueryInterface(aURL);
+	return NS_OK;
+}
+
+nsresult nsMsgProtocol::SetLoadGroup(nsILoadGroup * aLoadGroup)
+{
+	m_loadGroup = dont_QueryInterface(aLoadGroup);
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgProtocol::GetURI(nsIURI * *aURI)
+{
+	nsresult rv = NS_OK;
+	if (aURI)
+	{
+		if (m_url)
+			rv = m_url->QueryInterface(NS_GET_IID(nsIURI), (void **) aURI);
+		else
+			*aURI = nsnull;
+	}
+	else
+		rv = NS_ERROR_NULL_POINTER;
+	return rv;
+}
+ 
+NS_IMETHODIMP nsMsgProtocol::OpenInputStream(PRUint32 startPosition, PRInt32 readCount, nsIInputStream **_retval)
+{
+	return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgProtocol::OpenOutputStream(PRUint32 startPosition, nsIOutputStream **_retval)
+{
+	return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgProtocol::AsyncOpen(nsIStreamObserver *observer, nsISupports* ctxt)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgProtocol::AsyncRead(PRUint32 startPosition, PRInt32 readCount, nsISupports *ctxt, nsIStreamListener *listener)
+{
+	// set the stream listener and then load the url
+	m_channelContext = ctxt;
+	m_channelListener = listener;
+
+	// the following load group code is completely bogus....
+	nsresult rv = NS_OK;
+	if (m_loadGroup)
+	{
+		nsCOMPtr<nsILoadGroupListenerFactory> factory;
+		//
+		// Create a load group "proxy" listener...
+		//
+		rv = m_loadGroup->GetGroupListenerFactory(getter_AddRefs(factory));
+		if (factory) 
+		{
+			nsCOMPtr<nsIStreamListener> newListener;
+			rv = factory->CreateLoadGroupListener(m_channelListener, getter_AddRefs(newListener));
+			if (NS_SUCCEEDED(rv)) 
+				m_channelListener = newListener;
+		}
+	} // if aLoadGroup
+
+	return LoadUrl(m_url, nsnull);
+}
+
+NS_IMETHODIMP nsMsgProtocol::AsyncWrite(nsIInputStream *fromStream, PRUint32 startPosition, PRInt32 writeCount, nsISupports *ctxt, nsIStreamObserver *observer)
+{
+	return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgProtocol::GetLoadAttributes(nsLoadFlags *aLoadAttributes)
+{
+	return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgProtocol::SetLoadAttributes(nsLoadFlags aLoadAttributes)
+{
+	return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgProtocol::GetContentType(char * *aContentType)
+{
+	*aContentType = nsCRT::strdup("message/rfc822");
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgProtocol::GetContentLength(PRInt32 * aContentLength)
+{
+  *aContentLength = -1;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgProtocol::GetOwner(nsISupports * *aPrincipal)
+{
+	return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgProtocol::SetOwner(nsISupports * aPrincipal)
+{
+	return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgProtocol::GetLoadGroup(nsILoadGroup * *aLoadGroup)
+{
+	return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// From nsIRequest
+////////////////////////////////////////////////////////////////////////////////
+
+NS_IMETHODIMP nsMsgProtocol::IsPending(PRBool *result)
+{
+    *result = PR_TRUE;
+    return NS_OK; 
+}
+
+NS_IMETHODIMP nsMsgProtocol::Cancel()
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgProtocol::Suspend()
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgProtocol::Resume()
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}

mozilla/mailnews/base/util/nsMsgProtocol.h

@@ -0,0 +1,108 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef nsMsgProtocol_h__
+#define nsMsgProtocol_h__
+
+#include "nsIStreamListener.h"
+#include "nsIInputStream.h"
+#include "nsIOutputStream.h"
+#include "nsIEventQueue.h"
+#include "nsIChannel.h"
+#include "nsIURL.h"
+#include "nsILoadGroup.h"
+#include "nsCOMPtr.h"
+
+// This is a helper class used to encapsulate code shared between all of the
+// mailnews protocol objects (imap, news, pop, smtp, etc.) In particular,
+// it unifies the core networking code for the protocols. My hope is that
+// this will make unification with Necko easier as we'll only have to change
+// this class and not all of the mailnews protocols.
+class NS_MSG_BASE nsMsgProtocol : public nsIStreamListener, public nsIChannel
+{
+public:
+	nsMsgProtocol();
+	virtual ~nsMsgProtocol();
+
+	NS_DECL_ISUPPORTS
+	// nsIChannel support
+	NS_DECL_NSICHANNEL
+	NS_DECL_NSIREQUEST
+  
+  NS_DECL_NSISTREAMLISTENER
+  NS_DECL_NSISTREAMOBSERVER
+
+	// LoadUrl -- A protocol typically overrides this function, sets up any local state for the url and
+	// then calls the base class which opens the socket if it needs opened. If the socket is 
+	// already opened then we just call ProcessProtocolState to start the churning process.
+	// aConsumer is the consumer for the url. It can be null if this argument is not appropriate
+	virtual nsresult LoadUrl(nsIURI * aURL, nsISupports * aConsumer = nsnull);
+
+	virtual nsresult SetUrl(nsIURI * aURL); // sometimes we want to set the url before we load it
+	virtual nsresult SetLoadGroup(nsILoadGroup * aLoadGroup);
+
+	// Flag manipulators
+	PRBool TestFlag  (PRUint32 flag) {return flag & m_flags;}
+	void   SetFlag   (PRUint32 flag) { m_flags |= flag; }
+	void   ClearFlag (PRUint32 flag) { m_flags &= ~flag; }
+
+protected:
+	// methods for opening and closing a socket with core netlib....
+	// mscott -okay this is lame. I should break this up into a file protocol and a socket based
+	// protocool class instead of cheating and putting both methods here...
+	virtual nsresult OpenNetworkSocket(nsIURI * aURL); // open a connection on this url
+	virtual nsresult OpenFileSocket(nsIURI * aURL, const nsFileSpec * aFileSpec, PRUint32 aStartPosition, PRInt32 aReadCount); // used to open a file socket connection
+
+	// a Protocol typically overrides this method. They free any of their own connection state and then
+	// they call up into the base class to free the generic connection objects
+	virtual nsresult CloseSocket(); 
+
+	virtual nsresult SetupTransportState(); // private method used by OpenNetworkSocket and OpenFileSocket
+
+	// ProcessProtocolState - This is the function that gets churned by calls to OnDataAvailable. 
+	// As data arrives on the socket, OnDataAvailable calls ProcessProtocolState.
+	
+	virtual nsresult ProcessProtocolState(nsIURI * url, nsIInputStream * inputStream, 
+									      PRUint32 sourceOffset, PRUint32 length) = 0;
+
+	// SendData -- Writes the data contained in dataBuffer into the current output stream. 
+	// It also informs the transport layer that this data is now available for transmission.
+	// Returns a positive number for success, 0 for failure (not all the bytes were written to the
+	// stream, etc). 
+	virtual PRInt32 SendData(nsIURI * aURL, const char * dataBuffer);
+
+	// Ouput stream for writing commands to the socket
+	nsCOMPtr<nsIChannel>		m_channel; 
+	nsCOMPtr<nsIOutputStream>	m_outputStream;   // this will be obtained from the transport interface
+
+	PRBool	  m_socketIsOpen; // mscott: we should look into keeping this state in the nsSocketTransport...
+							  // I'm using it to make sure I open the socket the first time a URL is loaded into the connection
+	PRUint32	m_flags; // used to store flag information
+	PRUint32	m_startPosition;
+	PRInt32		m_readCount;
+
+	nsFileSpec	m_tempMsgFileSpec;  // we currently have a hack where displaying a msg involves writing it to a temp file first
+
+	// the following is a catch all for nsIChannel related data
+	nsCOMPtr<nsIURI>  m_url; // the running url
+	nsCOMPtr<nsIStreamListener> m_channelListener;
+	nsCOMPtr<nsISupports>		m_channelContext;
+	nsCOMPtr<nsILoadGroup>		m_loadGroup;
+};
+
+#endif /* nsMsgProtocol_h__ */

mozilla/mailnews/base/util/nsMsgTxn.cpp

@@ -0,0 +1,99 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998, 1999 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "nsMsgTxn.h"
+static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
+static NS_DEFINE_IID(kITransactionIID, NS_ITRANSACTION_IID);
+
+NS_IMPL_ADDREF(nsMsgTxn)
+NS_IMPL_RELEASE(nsMsgTxn)
+
+// note that aEditor is not refcounted
+nsMsgTxn::nsMsgTxn()
+{
+  NS_INIT_REFCNT();
+}
+
+nsMsgTxn::~nsMsgTxn()
+{
+}
+
+NS_IMETHODIMP nsMsgTxn::Do(void)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgTxn::GetIsTransient(PRBool *aIsTransient)
+{
+  if (nsnull!=aIsTransient)
+    *aIsTransient = PR_FALSE;
+  else
+	  return NS_ERROR_NULL_POINTER;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgTxn::Merge(PRBool *aDidMerge, nsITransaction *aTransaction)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgTxn::Write(nsIOutputStream *aOutputStream)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgTxn::GetUndoString(nsString *aString)
+{
+  if (nsnull!=aString)
+    *aString="Undo";
+  else
+	  return NS_ERROR_NULL_POINTER;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgTxn::GetRedoString(nsString *aString)
+{
+  if (nsnull!=aString)
+    *aString="Redo";
+  else
+	  return NS_ERROR_NULL_POINTER;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgTxn::QueryInterface(REFNSIID aIID, void** aInstancePtr)
+{
+  if (NULL == aInstancePtr) {
+    return NS_ERROR_NULL_POINTER;
+  }
+  if (aIID.Equals(kISupportsIID)) {
+    *aInstancePtr = (void*)(nsISupports*)this;
+    NS_ADDREF_THIS();
+    return NS_OK;
+  }
+  if (aIID.Equals(kITransactionIID)) {
+    *aInstancePtr = (void*)(nsITransaction*)this;
+    NS_ADDREF_THIS();
+    return NS_OK;
+  }
+  *aInstancePtr = 0;
+  return NS_NOINTERFACE;
+}
+
+
+

mozilla/mailnews/base/util/nsMsgTxn.h

@@ -0,0 +1,57 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998, 1999 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef nsMsgTxn_h__
+#define nsMsgTxn_h__
+
+#include "nsITransaction.h"
+#include "msgCore.h"
+
+#define NS_MESSAGETRANSACTION_IID \
+{ /* da621b30-1efc-11d3-abe4-00805f8ac968 */ \
+    0xda621b30, 0x1efc, 0x11d3, \
+	{ 0xab, 0xe4, 0x00, 0x80, 0x5f, 0x8a, 0xc9, 0x68 } }
+/**
+ * base class for all message undo/redo transactions.
+ */
+class NS_MSG_BASE nsMsgTxn : public nsITransaction
+{
+    NS_DECL_ISUPPORTS 
+
+    nsMsgTxn();
+    virtual ~nsMsgTxn();
+
+    NS_IMETHOD Do(void);
+    
+    NS_IMETHOD Undo(void) = 0;
+    
+    NS_IMETHOD Redo(void) = 0;
+    
+    NS_IMETHOD GetIsTransient(PRBool *aIsTransient);
+
+    NS_IMETHOD Merge(PRBool *aDidMerge, nsITransaction *aTransaction);
+
+    NS_IMETHOD Write(nsIOutputStream *aOutputStream);
+
+    NS_IMETHOD GetUndoString(nsString *aString);
+
+    NS_IMETHOD GetRedoString(nsString *aString);
+
+};
+
+#endif

mozilla/mailnews/base/util/nsMsgUtils.cpp

@@ -0,0 +1,326 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "msgCore.h"
+#include "nsIMessage.h"
+#include "nsIMsgHdr.h"
+#include "nsMsgUtils.h"
+#include "nsString.h"
+#include "nsFileSpec.h"
+#include "nsIServiceManager.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+#include "nsIImapUrl.h"
+#include "nsIMailboxUrl.h"
+#include "nsINntpUrl.h"
+#include "nsMsgNewsCID.h"
+#include "nsMsgLocalCID.h"
+#include "nsMsgBaseCID.h"
+#include "nsMsgImapCID.h"
+
+static NS_DEFINE_CID(kImapUrlCID, NS_IMAPURL_CID);
+static NS_DEFINE_CID(kCMailboxUrl, NS_MAILBOXURL_CID);
+static NS_DEFINE_CID(kCNntpUrlCID, NS_NNTPURL_CID);
+
+#if defined(DEBUG_sspitzer_) || defined(DEBUG_seth_)
+#define DEBUG_NS_MsgHashIfNecessary 1
+#endif
+
+nsresult GetMessageServiceProgIDForURI(const char *uri, nsString &progID)
+{
+
+	nsresult rv = NS_OK;
+	//Find protocol
+	nsString uriStr = uri;
+	PRInt32 pos = uriStr.FindChar(':');
+	if(pos == -1)
+		return NS_ERROR_FAILURE;
+	nsString protocol;
+	uriStr.Left(protocol, pos);
+
+	//Build message service progid
+	progID = "component://netscape/messenger/messageservice;type=";
+	progID += protocol;
+
+	return rv;
+}
+
+nsresult GetMessageServiceFromURI(const char *uri, nsIMsgMessageService **messageService)
+{
+
+	nsAutoString progID;
+	nsresult rv;
+
+	rv = GetMessageServiceProgIDForURI(uri, progID);
+
+	if(NS_SUCCEEDED(rv))
+	{
+		rv = nsServiceManager::GetService((const char *) nsCAutoString(progID), nsCOMTypeInfo<nsIMsgMessageService>::GetIID(),
+		           (nsISupports**)messageService, nsnull);
+	}
+
+	return rv;
+}
+
+
+nsresult ReleaseMessageServiceFromURI(const char *uri, nsIMsgMessageService *messageService)
+{
+	nsAutoString progID;
+	nsresult rv;
+
+	rv = GetMessageServiceProgIDForURI(uri, progID);
+	if(NS_SUCCEEDED(rv))
+		rv = nsServiceManager::ReleaseService(nsCAutoString(progID), messageService);
+	return rv;
+}
+
+
+nsresult CreateStartupUrl(char *uri, nsIURI** aUrl)
+{
+    nsresult rv = NS_ERROR_NULL_POINTER;
+    if (!uri || !*uri || !aUrl) return rv;
+    *aUrl = nsnull;
+    if (PL_strncasecmp(uri, "imap", 4) == 0)
+    {
+        nsCOMPtr<nsIImapUrl> imapUrl;
+        rv = nsComponentManager::CreateInstance(kImapUrlCID, nsnull,
+                                                nsIImapUrl::GetIID(),
+                                                getter_AddRefs(imapUrl));
+        if (NS_SUCCEEDED(rv) && imapUrl)
+            rv = imapUrl->QueryInterface(nsCOMTypeInfo<nsIURI>::GetIID(),
+                                         (void**) aUrl);
+    }
+    else if (PL_strncasecmp(uri, "mailbox", 7) == 0)
+    {
+        nsCOMPtr<nsIMailboxUrl> mailboxUrl;
+        rv = nsComponentManager::CreateInstance(kCMailboxUrl, nsnull,
+                                                nsIMailboxUrl::GetIID(),
+                                                getter_AddRefs(mailboxUrl));
+        if (NS_SUCCEEDED(rv) && mailboxUrl)
+            rv = mailboxUrl->QueryInterface(nsCOMTypeInfo<nsIURI>::GetIID(),
+                                            (void**) aUrl);
+    }
+    else if (PL_strncasecmp(uri, "news", 4) == 0)
+    {
+        nsCOMPtr<nsINntpUrl> nntpUrl;
+        rv = nsComponentManager::CreateInstance(kCNntpUrlCID, nsnull,
+                                                nsINntpUrl::GetIID(),
+                                                getter_AddRefs(nntpUrl));
+        if (NS_SUCCEEDED(rv) && nntpUrl)
+            rv = nntpUrl->QueryInterface(nsCOMTypeInfo<nsIURI>::GetIID(),
+                                         (void**) aUrl);
+    }
+    if (*aUrl)
+        (*aUrl)->SetSpec(uri);
+    return rv;
+}
+
+
+NS_IMPL_ISUPPORTS(nsMessageFromMsgHdrEnumerator, nsCOMTypeInfo<nsISimpleEnumerator>::GetIID())
+
+nsMessageFromMsgHdrEnumerator::nsMessageFromMsgHdrEnumerator(nsISimpleEnumerator *srcEnumerator,
+															 nsIMsgFolder *folder)
+{
+    NS_INIT_REFCNT();
+
+	mSrcEnumerator = dont_QueryInterface(srcEnumerator);
+	mFolder = dont_QueryInterface(folder);
+
+}
+
+nsMessageFromMsgHdrEnumerator::~nsMessageFromMsgHdrEnumerator()
+{
+	//member variables are nsCOMPtr's
+}
+
+
+NS_IMETHODIMP nsMessageFromMsgHdrEnumerator::GetNext(nsISupports **aItem)
+{
+	nsCOMPtr<nsISupports> currentItem;
+	nsCOMPtr<nsIMsgDBHdr> msgDBHdr;
+	nsCOMPtr<nsIMessage> message;
+	nsresult rv;
+
+	rv = mSrcEnumerator->GetNext(getter_AddRefs(currentItem));
+	if(NS_SUCCEEDED(rv))
+	{
+		msgDBHdr = do_QueryInterface(currentItem, &rv);
+	}
+
+	if(NS_SUCCEEDED(rv))
+	{
+		rv = mFolder->CreateMessageFromMsgDBHdr(msgDBHdr, getter_AddRefs(message));
+	}
+
+	if(NS_SUCCEEDED(rv))
+	{
+		currentItem = do_QueryInterface(message, &rv);
+		*aItem = currentItem;
+		NS_IF_ADDREF(*aItem);
+	}
+
+	NS_ASSERTION(NS_SUCCEEDED(rv),"getnext shouldn't fail");
+	return rv;
+}
+
+NS_IMETHODIMP nsMessageFromMsgHdrEnumerator::HasMoreElements(PRBool *aResult)
+{
+	return mSrcEnumerator->HasMoreElements(aResult);
+}
+
+nsresult NS_NewMessageFromMsgHdrEnumerator(nsISimpleEnumerator *srcEnumerator,
+										   nsIMsgFolder *folder,	
+										   nsMessageFromMsgHdrEnumerator **messageEnumerator)
+{
+	if(!messageEnumerator)
+		return NS_ERROR_NULL_POINTER;
+
+	*messageEnumerator =	new nsMessageFromMsgHdrEnumerator(srcEnumerator, folder);
+
+	if(!messageEnumerator)
+		return NS_ERROR_OUT_OF_MEMORY;
+
+	NS_ADDREF(*messageEnumerator);
+	return NS_OK;
+
+}
+
+// Where should this live? It's a utility used to convert a string priority, e.g., "High, Low, Normal" to an enum.
+// Perhaps we should have an interface that groups together all these utilities...
+nsresult NS_MsgGetPriorityFromString(const char *priority, nsMsgPriority *outPriority)
+{
+	if (!outPriority)
+		return NS_ERROR_NULL_POINTER;
+
+	nsMsgPriority retPriority = nsMsgPriorityNormal;
+
+	if (PL_strcasestr(priority, "Normal") != NULL)
+		retPriority = nsMsgPriorityNormal;
+	else if (PL_strcasestr(priority, "Lowest") != NULL)
+		retPriority = nsMsgPriorityLowest;
+	else if (PL_strcasestr(priority, "Highest") != NULL)
+		retPriority = nsMsgPriorityHighest;
+	else if (PL_strcasestr(priority, "High") != NULL || 
+			 PL_strcasestr(priority, "Urgent") != NULL)
+		retPriority = nsMsgPriorityHigh;
+	else if (PL_strcasestr(priority, "Low") != NULL ||
+			 PL_strcasestr(priority, "Non-urgent") != NULL)
+		retPriority = nsMsgPriorityLow;
+	else if (PL_strcasestr(priority, "1") != NULL)
+		retPriority = nsMsgPriorityHighest;
+	else if (PL_strcasestr(priority, "2") != NULL)
+		retPriority = nsMsgPriorityHigh;
+	else if (PL_strcasestr(priority, "3") != NULL)
+		retPriority = nsMsgPriorityNormal;
+	else if (PL_strcasestr(priority, "4") != NULL)
+		retPriority = nsMsgPriorityLow;
+	else if (PL_strcasestr(priority, "5") != NULL)
+	    retPriority = nsMsgPriorityLowest;
+	else
+		retPriority = nsMsgPriorityNormal;
+	*outPriority = retPriority;
+	return NS_OK;
+		//return nsMsgNoPriority;
+}
+
+
+nsresult NS_MsgGetUntranslatedPriorityName (nsMsgPriority p, nsString *outName)
+{
+	if (!outName)
+		return NS_ERROR_NULL_POINTER;
+	switch (p)
+	{
+	case nsMsgPriorityNotSet:
+	case nsMsgPriorityNone:
+		*outName = "None";
+		break;
+	case nsMsgPriorityLowest:
+		*outName = "Lowest";
+		break;
+	case nsMsgPriorityLow:
+		*outName = "Low";
+		break;
+	case nsMsgPriorityNormal:
+		*outName = "Normal";
+		break;
+	case nsMsgPriorityHigh:
+		*outName = "High";
+		break;
+	case nsMsgPriorityHighest:
+		*outName = "Highest";
+		break;
+	default:
+		NS_ASSERTION(PR_FALSE, "invalid priority value");
+	}
+	return NS_OK;
+}
+
+/* this used to be XP_StringHash2 from xp_hash.c */
+/* phong's linear congruential hash  */
+static PRUint32 StringHash(const char *ubuf)
+{
+  unsigned char * buf = (unsigned char*) ubuf;
+  PRUint32 h=1;
+  while(*buf) {
+    h = 0x63c63cd9*h + 0x9c39c33d + (int32)*buf;
+    buf++;
+  }
+  return h;
+}
+
+nsresult NS_MsgHashIfNecessary(nsCAutoString &name)
+{
+#if defined(XP_WIN16) || defined(XP_OS2)
+  const PRUint32 MAX_LEN = 8;
+#elif defined(XP_MAC)
+  const PRUint32 MAX_LEN = 25;
+#elif defined(XP_UNIX) || defined(XP_PC) || defined(XP_BEOS)
+  const PRUint32 MAX_LEN = 55;
+#else
+#error need_to_define_your_max_filename_length
+#endif
+  nsCAutoString str(name);
+
+#ifdef DEBUG_NS_MsgHashIfNecessary
+  printf("in: %s\n",str.GetBuffer());
+#endif
+
+  // Given a name, use either that name, if it fits on our
+  // filesystem, or a hashified version of it, if the name is too
+  // long to fit.
+  char hashedname[MAX_LEN + 1];
+  PRBool needshash = PL_strlen(str.GetBuffer()) > MAX_LEN;
+#if defined(XP_WIN16)  || defined(XP_OS2)
+  if (!needshash) {
+    needshash = PL_strchr(str.GetBuffer(), '.') != NULL ||
+      PL_strchr(str.GetBuffer(), ':') != NULL;
+  }
+#endif
+  PL_strncpy(hashedname, str.GetBuffer(), MAX_LEN + 1);
+  if (needshash) {
+    PR_snprintf(hashedname + MAX_LEN - 8, 9, "%08lx",
+                (unsigned long) StringHash(str.GetBuffer()));
+  }
+  name = hashedname;
+#ifdef DEBUG_NS_MsgHashIfNecessary
+  printf("out: %s\n",hashedname);
+#endif
+  
+  return NS_OK;
+}
+

mozilla/mailnews/base/util/nsMsgUtils.h

@@ -0,0 +1,67 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _NSMSGUTILS_H
+#define _NSMSGUTILS_H
+
+#include "nsIURL.h"
+#include "nsIMsgMessageService.h"
+#include "nsString.h"
+#include "nsIEnumerator.h"
+#include "nsIMsgFolder.h"
+#include "msgCore.h"
+#include "nsCOMPtr.h"
+
+//These are utility functions that can used throughout the mailnews code
+
+//Utilities for getting a message service.
+NS_MSG_BASE nsresult GetMessageServiceProgIDForURI(const char *uri, nsString &progID);
+//Use ReleaseMessageServiceFromURI to release the service.
+NS_MSG_BASE nsresult GetMessageServiceFromURI(const char *uri, nsIMsgMessageService **messageService);
+NS_MSG_BASE nsresult ReleaseMessageServiceFromURI(const char *uri, nsIMsgMessageService *messageService);
+
+NS_MSG_BASE nsresult CreateStartupUrl(char *uri, nsIURI** aUrl);
+
+//An enumerator for converting nsIMsgHdrs to nsIMessages.
+class NS_MSG_BASE nsMessageFromMsgHdrEnumerator: public nsISimpleEnumerator
+{
+protected:
+	nsCOMPtr<nsISimpleEnumerator> mSrcEnumerator;
+	nsCOMPtr<nsIMsgFolder> mFolder;
+
+public:
+	NS_DECL_ISUPPORTS
+	nsMessageFromMsgHdrEnumerator(nsISimpleEnumerator *srcEnumerator, nsIMsgFolder *folder);
+	nsMessageFromMsgHdrEnumerator(){} //Default constructor that does nothing so nsComPtr will work.
+	virtual ~nsMessageFromMsgHdrEnumerator();
+
+  NS_DECL_NSISIMPLEENUMERATOR
+};
+
+NS_MSG_BASE nsresult NS_NewMessageFromMsgHdrEnumerator(nsISimpleEnumerator *srcEnumerator,
+										   nsIMsgFolder *folder,	
+										   nsMessageFromMsgHdrEnumerator **messageEnumerator);
+
+NS_MSG_BASE nsresult NS_MsgGetPriorityFromString(const char *priority, nsMsgPriority *outPriority);
+
+NS_MSG_BASE nsresult NS_MsgGetUntranslatedPriorityName (nsMsgPriority p, nsString *outName);
+
+NS_MSG_BASE nsresult NS_MsgHashIfNecessary(nsCAutoString &name);
+
+#endif
+

mozilla/mailnews/base/util/nsNewsSummarySpec.cpp

@@ -0,0 +1,71 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "nsNewsSummarySpec.h"
+#include "plstr.h"
+#include "nsString.h"
+
+MOZ_DECL_CTOR_COUNTER(nsNewsSummarySpec);
+
+nsNewsSummarySpec::~nsNewsSummarySpec()
+{
+	MOZ_COUNT_DTOR(nsNewsSummarySpec);
+}
+
+nsNewsSummarySpec::nsNewsSummarySpec()
+{
+	MOZ_COUNT_CTOR(nsNewsSummarySpec);
+}
+
+nsNewsSummarySpec::nsNewsSummarySpec(const char *folderPath)
+  : nsFileSpec(folderPath)
+{
+	MOZ_COUNT_CTOR(nsNewsSummarySpec);
+	CreateSummaryFileName();
+}
+
+nsNewsSummarySpec::nsNewsSummarySpec(const nsFileSpec& inFolderPath)
+: nsFileSpec(inFolderPath)
+{
+	MOZ_COUNT_CTOR(nsNewsSummarySpec);
+	CreateSummaryFileName();
+}
+
+nsNewsSummarySpec::nsNewsSummarySpec(const nsFilePath &inFolderPath) : nsFileSpec(inFolderPath)
+{
+	MOZ_COUNT_CTOR(nsNewsSummarySpec);
+	CreateSummaryFileName();
+}
+
+void nsNewsSummarySpec::SetFolderName(const char *folderPath)
+{
+	*this = folderPath;
+}
+
+void nsNewsSummarySpec::CreateSummaryFileName()
+{
+	char *leafName = GetLeafName();
+
+    nsCAutoString fullLeafName((const char*)leafName);
+
+	// Append .msf (message summary file) 
+	fullLeafName += ".msf";	
+
+	SetLeafName(fullLeafName.GetBuffer());
+	PL_strfree(leafName);
+}

mozilla/mailnews/base/util/nsNewsSummarySpec.h

@@ -0,0 +1,45 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _nsNewsSummarySpec_H
+#define _nsNewsSummarySpec_H
+
+#include "nsFileSpec.h"
+#include "msgCore.h"
+
+// Class to name a summary file for a newsgroup,
+// given a full folder file spec. 
+// Note this class expects the invoking code to fully specify the folder path. 
+// This class does NOT prepend the local folder directory, or put .sbd on the containing
+// directory names.
+class NS_MSG_BASE nsNewsSummarySpec : public nsFileSpec
+{
+public:
+  nsNewsSummarySpec();
+  nsNewsSummarySpec(const char *folderPath);
+  nsNewsSummarySpec(const nsFileSpec& inFolderPath);
+  nsNewsSummarySpec(const nsFilePath &inFolderPath);
+  ~nsNewsSummarySpec();
+  void SetFolderName(const char *folderPath);
+
+protected:
+  void	CreateSummaryFileName();
+  
+};
+
+#endif /* _nsNewsSummarySpec_H */

mozilla/mailnews/base/util/nsUInt32Array.cpp

@@ -0,0 +1,277 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "msgCore.h"    // precompiled header...
+#include "prlog.h"
+
+#include "MailNewsTypes.h"
+#include "nsUInt32Array.h"
+#include "nsQuickSort.h"
+
+MOZ_DECL_CTOR_COUNTER(nsUInt32Array);
+
+nsUInt32Array::nsUInt32Array()
+{
+	MOZ_COUNT_CTOR(nsUInt32Array);
+	m_nSize = 0;
+	m_nMaxSize = 0;
+	m_nGrowBy = 0;
+	m_pData = NULL;
+}
+
+nsUInt32Array::~nsUInt32Array()
+{
+	MOZ_COUNT_DTOR(nsUInt32Array);
+	SetSize(0);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+PRUint32 nsUInt32Array::GetSize() const
+{
+	return m_nSize;
+}
+
+PRBool nsUInt32Array::SetSize(PRUint32 nSize,
+                              PRBool adjustGrowth,
+                              PRUint32 nGrowBy)
+{
+	if (adjustGrowth)
+		m_nGrowBy = nGrowBy;
+
+#ifdef MAX_ARR_ELEMS
+	if (nSize > MAX_ARR_ELEMS);
+	{
+		PR_ASSERT(nSize <= MAX_ARR_ELEMS); // Will fail
+		return PR_FALSE;
+	}
+#endif
+
+	if (nSize == 0)
+	{
+		// Remove all elements
+		PR_Free(m_pData);
+		m_nSize = 0;
+		m_nMaxSize = 0;
+		m_pData = NULL;
+	}
+	else if (m_pData == NULL)
+	{
+		// Create a new array
+		m_nMaxSize = PR_MAX(8, nSize);
+		m_pData = (PRUint32 *)PR_Calloc(1, m_nMaxSize * sizeof(PRUint32));
+		if (m_pData)
+			m_nSize = nSize;
+		else
+			m_nSize = m_nMaxSize = 0;
+	}
+	else if (nSize <= m_nMaxSize)
+	{
+		// The new size is within the current maximum size, make sure new
+		// elements are to initialized to zero
+		if (nSize > m_nSize)
+			nsCRT::memset(&m_pData[m_nSize], 0, (nSize - m_nSize) * sizeof(PRUint32));
+
+		m_nSize = nSize;
+	}
+	else
+	{
+		// The array needs to grow, figure out how much
+		PRUint32 nMaxSize;
+		nGrowBy  = PR_MAX(m_nGrowBy, PR_MIN(1024, PR_MAX(8, m_nSize / 8)));
+		nMaxSize = PR_MAX(nSize, m_nMaxSize + nGrowBy);
+#ifdef MAX_ARR_ELEMS
+		nMaxSize = PR_MIN(MAX_ARR_ELEMS, nMaxSize);
+#endif
+
+		PRUint32 *pNewData = (PRUint32 *)PR_Malloc(nMaxSize * sizeof(PRUint32));
+		if (pNewData)
+		{
+			// Copy the data from the old array to the new one
+			nsCRT::memcpy(pNewData, m_pData, m_nSize * sizeof(PRUint32));
+
+			// Zero out the remaining elements
+			nsCRT::memset(&pNewData[m_nSize], 0, (nSize - m_nSize) * sizeof(PRUint32));
+			m_nSize = nSize;
+			m_nMaxSize = nMaxSize;
+
+			// Free the old array
+			PR_Free(m_pData);
+			m_pData = pNewData;
+		}
+	}
+
+	return nSize == m_nSize;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+PRUint32 &nsUInt32Array::ElementAt(PRUint32 nIndex)
+{
+	PR_ASSERT(nIndex < m_nSize);
+	return m_pData[nIndex];
+}
+
+PRUint32 nsUInt32Array::GetAt(PRUint32 nIndex) const
+{
+	PR_ASSERT(nIndex < m_nSize);
+	return m_pData[nIndex];
+}
+
+PRUint32 *nsUInt32Array::GetData() 
+{
+	return m_pData;
+}
+
+void nsUInt32Array::SetAt(PRUint32 nIndex, PRUint32 newElement)
+{
+	PR_ASSERT(nIndex < m_nSize);
+	m_pData[nIndex] = newElement;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+PRUint32 nsUInt32Array::Add(PRUint32 newElement)
+{
+	PRUint32 nIndex = m_nSize;
+
+#ifdef MAX_ARR_ELEMS
+	if (nIndex >= MAX_ARR_ELEMS) 
+		return -1;	     
+#endif			
+
+	SetAtGrow(nIndex, newElement);
+	return nIndex;
+}
+
+PRUint32 nsUInt32Array::Add(PRUint32 *elementPtr, PRUint32 numElements) 
+{ 
+	if (SetSize(m_nSize + numElements))
+		nsCRT::memcpy(m_pData + m_nSize, elementPtr, numElements * sizeof(PRUint32)); 
+
+	return m_nSize; 
+} 
+
+PRUint32 *nsUInt32Array::CloneData() 
+{ 
+	PRUint32 *copyOfData = (PRUint32 *)PR_Malloc(m_nSize * sizeof(PRUint32)); 
+	if (copyOfData) 
+		nsCRT::memcpy(copyOfData, m_pData, m_nSize * sizeof(PRUint32)); 
+
+	return copyOfData; 
+} 
+
+void nsUInt32Array::InsertAt(PRUint32 nIndex, PRUint32 newElement, PRUint32 nCount)
+{
+	PR_ASSERT(nCount > 0);
+
+	if (nIndex >= m_nSize)
+	{
+		// If the new element is after the end of the array, grow the array
+		SetSize(nIndex + nCount);
+	}
+	else
+	{
+		// The element is being insert inside the array
+		int nOldSize = m_nSize;
+		SetSize(m_nSize + nCount);
+
+		// Move the data after the insertion point
+		nsCRT::memmove(&m_pData[nIndex + nCount], &m_pData[nIndex],
+			       (nOldSize - nIndex) * sizeof(PRUint32));
+	}
+
+	// Insert the new elements
+	PR_ASSERT(nIndex + nCount <= m_nSize);
+	while (nCount--)
+		m_pData[nIndex++] = newElement;
+}
+
+void nsUInt32Array::InsertAt(PRUint32 nStartIndex, const nsUInt32Array *pNewArray)
+{
+	PR_ASSERT(pNewArray != NULL);
+
+	if (pNewArray->GetSize() > 0)
+	{
+		InsertAt(nStartIndex, pNewArray->GetAt(0), pNewArray->GetSize());
+		for (PRUint32 i = 1; i < pNewArray->GetSize(); i++)
+			m_pData[nStartIndex + i] = pNewArray->GetAt(i);
+	}
+}
+
+void nsUInt32Array::RemoveAll()
+{
+	SetSize(0);
+}
+
+void nsUInt32Array::RemoveAt(PRUint32 nIndex, PRUint32 nCount)
+{
+	PR_ASSERT(nIndex + nCount <= m_nSize);
+
+	if (nCount > 0)
+	{
+		// Make sure not to overstep the end of the array
+		int nMoveCount = m_nSize - (nIndex + nCount);
+		if (nCount && nMoveCount)
+			nsCRT::memmove(&m_pData[nIndex], &m_pData[nIndex + nCount],
+		               nMoveCount * sizeof(PRUint32));
+
+		m_nSize -= nCount;
+	}
+}
+
+void nsUInt32Array::SetAtGrow(PRUint32 nIndex, PRUint32 newElement)
+{
+	if (nIndex >= m_nSize)
+		SetSize(nIndex+1);
+	m_pData[nIndex] = newElement;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+void nsUInt32Array::CopyArray(nsUInt32Array *oldA)
+{
+	CopyArray(*oldA);
+}
+
+void nsUInt32Array::CopyArray(nsUInt32Array &oldA)
+{
+	if (m_pData)
+		PR_Free(m_pData);
+	m_nSize = oldA.m_nSize;
+	m_nMaxSize = oldA.m_nMaxSize;
+	m_pData = (PRUint32 *)PR_Malloc(m_nSize * sizeof(PRUint32));
+	if (m_pData)
+		nsCRT::memcpy(m_pData, oldA.m_pData, m_nSize * sizeof(PRUint32));
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+static int CompareDWord (const void *v1, const void *v2, void *)
+{
+	// QuickSort callback to compare array values
+	PRUint32 i1 = *(PRUint32 *)v1;
+	PRUint32 i2 = *(PRUint32 *)v2;
+	return i1 - i2;
+}
+
+void nsUInt32Array::QuickSort (int (*compare) (const void *elem1, const void *elem2, void *data))
+{
+	if (m_nSize > 1)
+		NS_QuickSort(m_pData, m_nSize, sizeof(void*), compare ? compare : CompareDWord, nsnull);
+}

mozilla/mailnews/base/util/nsUInt32Array.h

@@ -0,0 +1,73 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+#ifndef _nsUInt32Array_H_
+#define _nsUInt32Array_H_
+
+#include "nscore.h"
+#include "nsCRT.h"
+#include "prmem.h"
+#include "msgCore.h"
+
+class NS_MSG_BASE nsUInt32Array
+{
+public:
+	// Construction/destruction
+    nsUInt32Array();
+    virtual ~nsUInt32Array();
+
+	// State/attribute member functions
+	PRUint32          GetSize() const;
+	PRBool            SetSize(PRUint32 nNewSize, PRBool AdjustGrowth=PR_FALSE, PRUint32 nGrowBy = 0);
+
+	// Accessor member functions
+	PRUint32            &ElementAt(PRUint32 nIndex);
+	PRUint32             GetAt(PRUint32 nIndex) const;
+	PRUint32            *GetData();
+	void               SetAt(PRUint32 nIndex, PRUint32 newElement);
+
+	// Insertion/deletion member functions
+	PRUint32			Add(PRUint32 newElement);
+	PRUint32           Add(PRUint32 *elementPtr, PRUint32 numElements); 
+	void	           InsertAt(PRUint32 nIndex, PRUint32 newElement, PRUint32 nCount = 1);
+	void               InsertAt(PRUint32 nStartIndex, const nsUInt32Array *pNewArray);
+	void               RemoveAll();
+	void               RemoveAt(PRUint32 nIndex, PRUint32 nCount = 1);
+	void               SetAtGrow(PRUint32 nIndex, PRUint32 newElement);
+
+	// Sorting member functions
+	void               QuickSort(int (*compare) (const void *elem1, const void *elem2, void *) = NULL);
+
+	// Overloaded operators
+	PRUint32             operator[](PRUint32 nIndex) const { return GetAt(nIndex); }
+	PRUint32            &operator[](PRUint32 nIndex) { return ElementAt(nIndex); }
+
+	// Miscellaneous member functions
+	PRUint32            *CloneData(); 
+	void               CopyArray(nsUInt32Array *oldA);
+	void               CopyArray(nsUInt32Array &oldA);
+
+protected:
+    // Member data
+	PRUint32 m_nSize;
+	PRUint32 m_nMaxSize;
+	PRUint32 m_nGrowBy;
+	PRUint32* m_pData;
+};
+
+
+#endif // _DWordArray_H_

mozilla/security/psm/lib/Makefile

@@ -1,74 +0,0 @@
-#! gmake
-#
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-#
-
-#######################################################################
-# (1) Include initial platform-independent assignments (MANDATORY).   #
-#######################################################################
-
-include manifest.mn
-
-#######################################################################
-# (2) Include "global" configuration information. (OPTIONAL)          #
-#######################################################################
-
-include $(CORE_DEPTH)/coreconf/config.mk
-
-#######################################################################
-# (3) Include "component" configuration information. (OPTIONAL)       #
-#######################################################################
-
-
-
-#######################################################################
-# (4) Include "local" platform-dependent assignments (OPTIONAL).      #
-#######################################################################
-
-
-
-#######################################################################
-# (5) Execute "global" rules. (OPTIONAL)                              #
-#######################################################################
-
-include $(CORE_DEPTH)/coreconf/rules.mk
-
-#######################################################################
-# (6) Execute "component" rules. (OPTIONAL)                           #
-#######################################################################
-
-
-
-#######################################################################
-# (7) Execute "local" rules. (OPTIONAL).                              #
-#######################################################################
-

mozilla/security/psm/lib/Makefile.in

@@ -1,32 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-#
-
-DEPTH		= ../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-DIRS		= protocol client
-
-include $(topsrcdir)/config/rules.mk
-

mozilla/security/psm/lib/client/MANIFEST

@@ -1,3 +0,0 @@
-cmtclist.h
-cmtcmn.h
-cmtjs.h

mozilla/security/psm/lib/client/Makefile

@@ -1,74 +0,0 @@
-#! gmake
-#
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-#
-
-#######################################################################
-# (1) Include initial platform-independent assignments (MANDATORY).   #
-#######################################################################
-
-include manifest.mn
-
-#######################################################################
-# (2) Include "global" configuration information. (OPTIONAL)          #
-#######################################################################
-
-include $(CORE_DEPTH)/coreconf/config.mk
-
-#######################################################################
-# (3) Include "component" configuration information. (OPTIONAL)       #
-#######################################################################
-
-
-
-#######################################################################
-# (4) Include "local" platform-dependent assignments (OPTIONAL).      #
-#######################################################################
-include config.mk
-
-
-#######################################################################
-# (5) Execute "global" rules. (OPTIONAL)                              #
-#######################################################################
-
-include $(CORE_DEPTH)/coreconf/rules.mk
-
-#######################################################################
-# (6) Execute "component" rules. (OPTIONAL)                           #
-#######################################################################
-
-
-
-#######################################################################
-# (7) Execute "local" rules. (OPTIONAL).                              #
-#######################################################################
-

mozilla/security/psm/lib/client/Makefile.in

@@ -1,70 +0,0 @@
-#! gmake
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-# 
-
-DEPTH		= ../../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-LIBRARY_NAME	= cmt
-
-EXPORTS = \
-	cmtcmn.h \
-	cmtjs.h  \
-	cmtclist.h \
-	$(NULL)
-
-MODULE = security
-
-CSRCS = cmtinit.c  \
-	cmtssl.c   \
-	cmtutils.c \
-	cmtcert.c  \
-	cmthash.c  \
-	cmtpkcs7.c \
-	cmtres.c   \
-	cmtjs.c    \
-	cmtevent.c \
-        cmtpasswd.c \
-	cmtadvisor.c \
-	cmtrng.c \
-	cmtsdr.c \
-	$(NULL)
-
-EXTRA_DSO_LDOPTS	+= -L$(DIST)/bin -lprotocol
-
-include $(topsrcdir)/config/rules.mk
-

mozilla/security/psm/lib/client/cmtadvisor.c

@@ -1,99 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "messages.h"
-#ifdef XP_MAC
-#include "cmtmac.h"
-#endif
-
-CMTStatus CMT_SecurityAdvisor(PCMT_CONTROL control, CMTSecurityAdvisorData* data, CMUint32 *resID)
-{
-    CMTItem message = {0, NULL, 0};
-    SecurityAdvisorRequest request;
-    SingleNumMessage reply;
-
-    if (!control) {
-        return CMTFailure;
-    }
-
-    if (!data) {
-        return CMTFailure;
-    }
-
-    request.infoContext = data->infoContext;
-    request.resID = data->resID;
-    request.hostname = data->hostname;
-	request.senderAddr = data->senderAddr;
-	request.encryptedP7CInfo = data->encryptedP7CInfo;
-	request.signedP7CInfo = data->signedP7CInfo;
-	request.decodeError = data->decodeError;
-	request.verifyError = data->verifyError;
-	request.encryptthis = data->encryptthis;
-	request.signthis = data->signthis;
-	request.numRecipients = data->numRecipients;
-	request.recipients = data->recipients;
-    message.type = SSM_REQUEST_MESSAGE | SSM_SECURITY_ADVISOR;
-
-    if (CMT_EncodeMessage(SecurityAdvisorRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Send the message and get the response */
-	if (CMT_SendMessage(control, &message) != CMTSuccess) {
-        goto loser;
-	}
-
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_SECURITY_ADVISOR)) {
-        goto loser;
-    }
-
-    /* Decode the message */
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *resID = reply.value;
-
-    return CMTSuccess;
-loser:
-
-    if (message.data) {
-        free(message.data);
-    }
-    return CMTFailure;
-}
-
-
-
-

mozilla/security/psm/lib/client/cmtclist.h

@@ -1,111 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifndef cmtclist_h___
-#define cmtclist_h___
-
-typedef struct CMTCListStr CMTCList;
-/*
-** Circular linked list
-*/
-struct CMTCListStr {
-    CMTCList	*next;
-    CMTCList	*prev;
-};
-
-/*
-** Insert element "_e" into the list, before "_l".
-*/
-#define CMT_INSERT_BEFORE(_e,_l)	 \
-	(_e)->next = (_l);	 \
-	(_e)->prev = (_l)->prev; \
-	(_l)->prev->next = (_e); \
-	(_l)->prev = (_e);	 \
-
-/*
-** Insert element "_e" into the list, after "_l".
-*/
-#define CMT_INSERT_AFTER(_e,_l)	 \
-	(_e)->next = (_l)->next; \
-	(_e)->prev = (_l);	 \
-	(_l)->next->prev = (_e); \
-	(_l)->next = (_e);	 \
-
-/*
-** Append an element "_e" to the end of the list "_l"
-*/
-#define CMT_APPEND_LINK(_e,_l) CMT_INSERT_BEFORE(_e,_l)
-
-/*
-** Insert an element "_e" at the head of the list "_l"
-*/
-#define CMT_INSERT_LINK(_e,_l) CMT_INSERT_AFTER(_e,_l)
-
-/* Return the head/tail of the list */
-#define CMT_LIST_HEAD(_l) (_l)->next
-#define CMT_LIST_TAIL(_l) (_l)->prev
-
-/*
-** Remove the element "_e" from it's circular list.
-*/
-#define CMT_REMOVE_LINK(_e)	       \
-	(_e)->prev->next = (_e)->next; \
-	(_e)->next->prev = (_e)->prev; \
-
-/*
-** Remove the element "_e" from it's circular list. Also initializes the
-** linkage.
-*/
-#define CMT_REMOVE_AND_INIT_LINK(_e)    \
-	(_e)->prev->next = (_e)->next; \
-	(_e)->next->prev = (_e)->prev; \
-	(_e)->next = (_e);	       \
-	(_e)->prev = (_e);	       \
-
-/*
-** Return non-zero if the given circular list "_l" is empty, zero if the
-** circular list is not empty
-*/
-#define CMT_CLIST_IS_EMPTY(_l) \
-    ((_l)->next == (_l))
-
-/*
-** Initialize a circular list
-*/
-#define CMT_INIT_CLIST(_l)  \
-	(_l)->next = (_l); \
-	(_l)->prev = (_l); \
-
-#define CMT_INIT_STATIC_CLIST(_l) \
-    {(_l), (_l)}
-
-#endif /* cmtclist_h___ */

mozilla/security/psm/lib/client/cmtevent.c

@@ -1,480 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "messages.h"
-#include <string.h>
-#ifdef XP_UNIX
-#include <sys/time.h>
-#endif
-
-/* Typedefs */
-typedef void (*taskcompleted_handler_fn)(CMUint32 resourceID, CMUint32 numReqProcessed, CMUint32 resultCode, void* data);
-
-CMTStatus CMT_SetUIHandlerCallback(PCMT_CONTROL control, 
-                                   uiHandlerCallback_fn f, void *data)
-{
-    return CMT_RegisterEventHandler(control, SSM_UI_EVENT, 0,
-                                    (void_fun)f, data);
-}
-
-void CMT_SetFilePathPromptCallback(PCMT_CONTROL control,
-                                   filePathPromptCallback_fn f, void* arg)
-{
-    control->userFuncs.promptFilePath = f;
-    control->userFuncs.filePromptArg  = arg;
-}
-
-void CMT_SetPromptCallback(PCMT_CONTROL control, 
-                           promptCallback_fn f, void *arg)
-{
-    control->userFuncs.promptCallback = f;
-    control->userFuncs.promptArg      = arg;
-}
-
-void CMT_SetSavePrefsCallback(PCMT_CONTROL control, savePrefsCallback_fn f)
-{
-    control->userFuncs.savePrefs = f;
-}
-
-CMTStatus CMT_RegisterEventHandler(PCMT_CONTROL control, CMUint32 type, 
-                                   CMUint32 resourceID, void_fun handler, 
-                                   void* data)
-{
-    PCMT_EVENT ptr;
-
-    /* This is the first connection */
-    if (control->cmtEventHandlers == NULL) {
-        control->cmtEventHandlers = ptr = 
-            (PCMT_EVENT)calloc(sizeof(CMT_EVENT), 1);
-        if (!ptr) {
-            goto loser;
-        }
-    } else {
-        /* Look for another event handler of the same type.  Make sure the
-           event handler with a rsrcid of 0 is farther down the list so
-	   that it doesn't get chosen when there's an event handler for
-	   a specific rsrcid.
-	 */
-	for (ptr=control->cmtEventHandlers; ptr != NULL; ptr = ptr->next) {
-            if (ptr->type == type && resourceID != 0) {
-                /* So we've got an event handler that wants to over-ride
-                   an existing event handler.  We'll put it before the one
-                   that's already here.
-                 */
-                if (ptr->previous == NULL) {
-                    /* We're going to insert at the front of the list*/
-                    control->cmtEventHandlers = ptr->previous = 
-                        (PCMT_EVENT)calloc(sizeof(CMT_EVENT), 1);
-                    if (ptr->previous == NULL) {
-                        goto loser;
-		    }
-		    ptr->previous->next = ptr;
-		    ptr = control->cmtEventHandlers;
-		} else {
-		    /* We want to insert in the middle of the list */
-		    PCMT_EVENT tmpEvent;
-		    
-		    tmpEvent = (PCMT_EVENT)calloc(sizeof(CMT_EVENT), 1);
-		    if (tmpEvent == NULL) {
-		        goto loser;
-		    }
-		    tmpEvent->previous  = ptr->previous;
-		    ptr->previous->next = tmpEvent;
-		    tmpEvent->next      = ptr;
-		    ptr->previous       = tmpEvent;
-		    ptr = tmpEvent;
-		}
-		break;
-	    }
-	    if (ptr->next == NULL) break;
-	}
-	if (ptr == NULL) {
-	    goto loser;	
-	}
-	if (ptr->next == NULL) {
-	    /* We're adding the event handler at the end of the list. */
-	    ptr->next = (PCMT_EVENT)calloc(sizeof(CMT_EVENT), 1);
-	    if (!ptr->next) {
-	        goto loser;
-	    } 
-	    /* Fix up the pointers */
-	    ptr->next->previous = ptr;
-	    ptr = ptr->next;
-	}
-    }
-
-    /* Fill in the data */
-    ptr->type = type;
-    ptr->resourceID = resourceID;
-    ptr->handler = handler;
-    ptr->data = data;
-    
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_UnregisterEventHandler(PCMT_CONTROL control, CMUint32 type, 
-                                     CMUint32 resourceID) 
-{
-    PCMT_EVENT ptr, pptr = NULL;
-    
-    for (ptr = control->cmtEventHandlers; ptr != NULL;
-	 pptr = ptr, ptr = ptr->next) {
-        if ((ptr->type == type) && (ptr->resourceID == resourceID)) {
-	    if (pptr == NULL) {
-	        /* node is at head */
-	        control->cmtEventHandlers = ptr->next;
-            if (control->cmtEventHandlers != NULL) {
-                control->cmtEventHandlers->previous = NULL;
-            }
-            free(ptr);
-            return CMTSuccess;
-	    }
-	    /* node is elsewhere */
-	    pptr->next = ptr->next;
-        if (ptr->next != NULL) {
-            ptr->next->previous = pptr;
-        }
-	    free(ptr);
-	    return CMTSuccess;
-        }
-    }
-    return CMTFailure;
-}
-
-PCMT_EVENT CMT_GetEventHandler(PCMT_CONTROL control, CMUint32 type, 
-                               CMUint32 resourceID)
-{
-    PCMT_EVENT ptr;
-    
-    for (ptr = control->cmtEventHandlers; ptr != NULL; ptr = ptr->next) {
-        if ((ptr->type == type) && ((ptr->resourceID == resourceID) || 
-                                    !ptr->resourceID)) {
-            return ptr;
-        }
-    }
-    return NULL;
-}
-
-PCMT_EVENT CMT_GetFirstEventHandler(PCMT_CONTROL control, CMUint32 type, 
-                                    CMUint32 resourceID)
-{
-    PCMT_EVENT ptr;
-
-    for (ptr = control->cmtEventHandlers; ptr != NULL; ptr = ptr->next) {
-        if ((ptr->type == type) && ((ptr->resourceID == resourceID) || 
-                                    !ptr->resourceID)) {
-            return ptr;
-        }
-    }
-    return NULL;
-}
-
-PCMT_EVENT CMT_GetNextEventHandler(PCMT_CONTROL control, PCMT_EVENT e)
-{
-    PCMT_EVENT ptr;
-
-    for (ptr = control->cmtEventHandlers; ptr != NULL || ptr == e; 
-         ptr = ptr->next) {
-    }
-
-    for (; ptr != NULL; ptr = ptr->next) {
-        if ((ptr->type == e->type) && ((ptr->resourceID == e->resourceID) || 
-                                       !ptr->resourceID)) {
-            return ptr;
-        }
-    }
-    return NULL;
-}
-
-void CMT_ProcessEvent(PCMT_CONTROL cm_control)
-{
-    CMTSocket sock; 
-    CMTItem eventData={ 0, NULL, 0 };
-
-    /* Get the control socket */
-    sock = cm_control->sock;
-
-    /* Acquire a lock on the control connection */
-    CMT_LOCK(cm_control->mutex);
-    /* Do another select here to be sure 
-       that the socket is readable */
-    if (cm_control->sockFuncs.select(&sock, 1, 1) != sock) {
-        /* There's no event. */
-        goto done;
-    }
-
-    /* Read the event */
-    if (CMT_ReceiveMessage(cm_control, &eventData) == CMTFailure) {
-        goto done;
-    }
-    CMT_UNLOCK(cm_control->mutex);
-    /* Dispatch the event */
-    CMT_DispatchEvent(cm_control, &eventData);
-    return;
-done:
-    /* Release the lock on the control connection */
-    CMT_UNLOCK(cm_control->mutex);
-}
-
-void CMT_EventLoop(PCMT_CONTROL cm_control)
-{
-    CMTSocket sock;
-
-    /* Get the control socket */
-    sock = cm_control->sock;
-    CMT_ReferenceControlConnection(cm_control);
-    /* Select on the control socket to see if it's readable */
-    while(cm_control->sockFuncs.select(&sock, 1, 0)) {
-      CMT_ProcessEvent(cm_control);
-    }
-    CMT_CloseControlConnection(cm_control);
-    return;
-}
-
-void
-CMT_PromptUser(PCMT_CONTROL cm_control, CMTItem *eventData)
-{
-    char *promptReply  = NULL;
-    CMTItem   response={ 0, NULL, 0 };
-    PromptRequest request;
-    PromptReply reply;
-    void * clientContext;
-
-    /* Decode the message */
-    if (CMT_DecodeMessage(PromptRequestTemplate, &request, eventData) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Copy the client context to a pointer */
-    clientContext = CMT_CopyItemToPtr(request.clientContext);
-
-    if (cm_control->userFuncs.promptCallback == NULL) {
-        goto loser;
-    }
-    promptReply = 
-        cm_control->userFuncs.promptCallback(cm_control->userFuncs.promptArg, 
-                                             request.prompt, clientContext, 1);
-
-    response.type = SSM_EVENT_MESSAGE | SSM_PROMPT_EVENT;
-    if (!promptReply) {
-        /* the user canceled the prompt or other errors occurred */
-        reply.cancel = CM_TRUE;
-    }
-    else {
-        /* note that this includes an empty string (zero length) password */
-        reply.cancel = CM_FALSE;
-    }
-    reply.resID = request.resID;
-    reply.promptReply = promptReply;
-
-    /* Encode the message */
-    if (CMT_EncodeMessage(PromptReplyTemplate, &response, &reply) != CMTSuccess) {
-        goto loser;
-    }
-
-    CMT_TransmitMessage(cm_control, &response);
- loser:
-    if (promptReply != NULL) {
-      cm_control->userFuncs.userFree(promptReply);
-    }
-    return;
-}
-
-void CMT_GetFilePath(PCMT_CONTROL cm_control, CMTItem * eventData)
-{
-    char *fileName=NULL;
-    CMTItem response = { 0, NULL, 0 };
-    FilePathRequest request;
-    FilePathReply reply;
-
-    /* Decode the request */
-    if (CMT_DecodeMessage(FilePathRequestTemplate, &request, eventData) != CMTSuccess) {
-        goto loser;
-    }
-
-    if (cm_control->userFuncs.promptFilePath == NULL) {
-        goto loser;
-    }
-    fileName = 
-     cm_control->userFuncs.promptFilePath(cm_control->userFuncs.filePromptArg,
-                                          request.prompt, request.fileRegEx, 
-                                          request.getExistingFile);
-
-    response.type = SSM_EVENT_MESSAGE | SSM_FILE_PATH_EVENT;
-    reply.resID = request.resID;
-    reply.filePath = fileName;
-
-    /* Encode the reply */
-    if (CMT_EncodeMessage(FilePathReplyTemplate, &response, &reply) != CMTSuccess) {
-        goto loser;
-    }
-
-    CMT_TransmitMessage(cm_control, &response);
-    cm_control->userFuncs.userFree(fileName); 
-loser:
-   return;
-}
-
-void CMT_SavePrefs(PCMT_CONTROL cm_control, CMTItem* eventData)
-{
-    SetPrefListMessage request;
-    int i;
-
-    /* decode the request */
-    if (CMT_DecodeMessage(SetPrefListMessageTemplate, &request, eventData) !=
-        CMTSuccess) {
-        return;
-    }
-
-    if (cm_control->userFuncs.savePrefs == NULL) {
-        /* callback was not registered: bail */
-        return;
-    }
-    cm_control->userFuncs.savePrefs(request.length, 
-                                    (CMTSetPrefElement*)request.list);
-
-    for (i = 0; i < request.length; i++) {
-        if (request.list[i].key != NULL) {
-            free(request.list[i].key);
-        }
-        if (request.list[i].value != NULL) {
-            free(request.list[i].value);
-        }
-    }
-    return;
-}
-
-void CMT_DispatchEvent(PCMT_CONTROL cm_control, CMTItem * eventData)
-{
-    CMUint32 eventType;
-    CMTItem msgCopy;
-
-    /* Init the msgCopy */
-    msgCopy.data = 0;    
-
-    /* Get the event type */
-    if ((eventData->type & SSM_CATEGORY_MASK) != SSM_EVENT_MESSAGE) {
-        /* Somehow there was a message on the socket that was not 
-         * an event message.  Dropping it on the floor.
-         */
-        goto loser;
-    }
-    eventType = (eventData->type & SSM_TYPE_MASK);
-
-    /* We must now dispatch the event based on it's type */
-    switch (eventType) {
-        case SSM_UI_EVENT:
-        {
-            PCMT_EVENT p;
-            UIEvent event;
-            void * clientContext = NULL;
-
-	    /* Copy the message to allow a second try with the old format */
-	    msgCopy.len = eventData->len;
-	    msgCopy.data = calloc(msgCopy.len, 1);
-	    if (msgCopy.data) {
-              memcpy(msgCopy.data, eventData->data, eventData->len);
-	    }
-
-            /* Get the event data first */
-            if (CMT_DecodeMessage(UIEventTemplate, &event, eventData) != CMTSuccess) {
-		/* Attempt to decode using the old format.  Modal is True */
-		if (!msgCopy.data || 
-		    CMT_DecodeMessage(OldUIEventTemplate, &event, &msgCopy) != CMTSuccess) {
-                  goto loser;
-                }
-
-                /* Set default modal value */
-                event.isModal = CM_TRUE;
-            }
-
-            /* Convert the client context to a pointer */
-            clientContext = CMT_CopyItemToPtr(event.clientContext);
-
-            /* Call any handlers for this event */
-            p = CMT_GetEventHandler(cm_control, eventType, event.resourceID);
-            if (!p) {
-                goto loser;
-            }
-            (*(uiHandlerCallback_fn)(p->handler))(event.resourceID, 
-                                                  clientContext, event.width,
-                                                  event.height, event.isModal, event.url, 
-                                                  p->data);
-            break;
-        }
-
-        case SSM_TASK_COMPLETED_EVENT:
-        {
-           PCMT_EVENT p;
-           TaskCompletedEvent event;
-
-            /* Get the event data */
-            if (CMT_DecodeMessage(TaskCompletedEventTemplate, &event, eventData) != CMTSuccess) {
-                goto loser;
-            }
-
-            /* Call handler for this event */
-            p = CMT_GetEventHandler(cm_control, eventType, event.resourceID);
-            if (!p) {
-                goto loser;
-            }
-            (*(taskcompleted_handler_fn)(p->handler))(event.resourceID, 
-                                                      event.numTasks, 
-                                                      event.result, p->data);
-            break;
-        }
-        case SSM_AUTH_EVENT: 
-             CMT_ServicePasswordRequest(cm_control, eventData);
-             break;
-        case SSM_FILE_PATH_EVENT:
-    	     CMT_GetFilePath(cm_control, eventData);
-             break;
-        case SSM_PROMPT_EVENT:
-	         CMT_PromptUser(cm_control, eventData);
-	         break;
-        case SSM_SAVE_PREF_EVENT:
-            CMT_SavePrefs(cm_control, eventData);
-            break;
-        default:
-            break;
-    }
-loser:
-    free(eventData->data);
-    free(msgCopy.data);
-    return;
-}
-

mozilla/security/psm/lib/client/cmthash.c

@@ -1,216 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifdef XP_UNIX
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#else
-#ifdef XP_MAC
-#include "macsocket.h"
-#include "string.h"
-#else
-#include <windows.h>
-#include <winsock.h>
-#endif
-#endif
-#include <errno.h>
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "messages.h"
-#include "rsrcids.h"
-
-CMTStatus CMT_HashCreate(PCMT_CONTROL control, CMUint32 algID, 
-                         CMUint32 * connID)
-{
-    CMTItem message;
-    SingleNumMessage request;
-    DataConnectionReply reply;
-
-    /* Check passed in parameters */
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.value = algID;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(SingleNumMessageTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_DATA_CONNECTION | SSM_HASH_STREAM;
-
-    /* Send the message and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the response */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_DATA_CONNECTION | SSM_HASH_STREAM)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(DataConnectionReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Success */
-    if (reply.result == 0) {
-        CMTSocket sock;
-
-        sock = control->sockFuncs.socket(0);
-        if(sock == NULL) {
-            goto loser;
-        }
-        
-        if (control->sockFuncs.connect(sock, reply.port, NULL) != CMTSuccess) {
-            goto loser;
-        }
-        /* Send the hello message */
-		control->sockFuncs.send(sock, control->nonce.data, control->nonce.len);
-
-        /* Save connection info */
-        if (CMT_AddDataConnection(control, sock, reply.connID)
-		    != CMTSuccess) {
-            goto loser;
-        }
-
-        /* Set the connection ID */
-        *connID = reply.connID;
-        return CMTSuccess;
-	} 
-loser:
-    *connID = 0;
-	return CMTFailure;
-}
-
-CMTStatus CMT_HASH_Destroy(PCMT_CONTROL control, CMUint32 connectionID)
-{
-    if (!control) {
-        goto loser;
-    }
-
-    /* Get the cotext implementation data */
-    if (CMT_CloseDataConnection(control, connectionID) == CMTFailure) {
-        goto loser;
-    }
-
-    return CMTSuccess;
-
-loser:
-
-    return CMTFailure;
-}
-
-CMTStatus CMT_HASH_Begin(PCMT_CONTROL control, CMUint32 connectionID)
-{
-    return CMTSuccess;
-}
-
-CMTStatus CMT_HASH_Update(PCMT_CONTROL control, CMUint32 connectionID, const unsigned char * buf, CMUint32 len)
-{
-    CMTSocket sock;
-    CMUint32 sent;
-
-    /* Do some parameter checking */
-    if (!control || !buf) {
-        goto loser;
-    }
-
-    /* Get the data socket */
-    if (CMT_GetDataSocket(control, connectionID, &sock) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Write the data to the socket */
-    sent = CMT_WriteThisMany(control, sock, (void*)buf, len);
-    if (sent != len) {
-        goto loser;
-    }
-
-    return CMTSuccess;
-
-loser:
-
-    return CMTFailure;
-}
-
-CMTStatus CMT_HASH_End(PCMT_CONTROL control, CMUint32 connectionID, 
-                       unsigned char * result, CMUint32 * resultlen, 
-                       CMUint32 maxLen)
-{
-    CMTItem hash = { 0, NULL, 0 };
-
-    /* Do some parameter checking */
-    if (!control || !result || !resultlen) {
-        goto loser;
-    }
-
-    /* Close the connection */
-    if (CMT_CloseDataConnection(control, connectionID) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Get the context info */
-    if (CMT_GetStringAttribute(control, connectionID, SSM_FID_HASHCONN_RESULT,
-                               &hash) == CMTFailure) {
-        goto loser;
-    }
-    if (!hash.data) {
-        goto loser;
-    }
-
-    *resultlen = hash.len;
-    if (hash.len > maxLen) {
-        memcpy(result, hash.data, maxLen);
-    } else {
-        memcpy(result, hash.data, hash.len);
-    }   
-
-    if (hash.data) {
-        free(hash.data);
-    }
-
-    return CMTSuccess;
-
-loser:
-    if (hash.data) {
-        free(hash.data);
-    }
-
-    return CMTFailure;
-}

mozilla/security/psm/lib/client/cmtimpl.h

@@ -1,56 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifndef __CMTIMPL_H_
-#define __CMTIMPL_H_
-
-typedef unsigned long CMT_HANDLE;
-
-struct _CMTControl {
-  CMT_HANDLE channelID;
-  int socketID;
-  CMTStatus (* cmtEventCallback)(struct _CMTControl * control, 
-				 CMTItem * event,  void * arg);
-  void * cmtEventCallbackArg;
-  struct _CMTData * cmtDataConnection;
-} _CMTControl;
-
-
-
-struct _CMTData {
-  CMT_HANDLE channelID;
-  int socketID;
-  struct _CMTData * next;
-  struct _CMTData * previous;
-};
-
-#endif /*__CMTIMPL_H_*/

mozilla/security/psm/lib/client/cmtinit.c

@@ -1,484 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifdef XP_UNIX
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <sys/stat.h>
-#include <netinet/tcp.h>
-#else
-#ifdef XP_MAC
-#include <Events.h> // for WaitNextEvent
-#else /* Windows */
-#include <windows.h>
-#include <winsock.h>
-#include <direct.h>
-#include <sys/stat.h>
-#endif
-#endif
-
-#include "messages.h"
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include <string.h>
-
-#ifdef XP_UNIX
-#define DIRECTORY_SEPARATOR '/'
-#elif defined WIN32
-#define DIRECTORY_SEPARATOR '\\'
-#elif defined XP_MAC
-#define DIRECTORY_SEPARATOR ':'
-#endif
-
-/* Local defines */
-#define CARTMAN_PORT	11111
-#define MAX_PATH_LEN    256
-
-/* write to the cmnav.log */
-#if 0
-#define LOG(x); do { FILE *f; f=fopen("cmnav.log","a+"); if (f) { \
-   fprintf(f, x); fclose(f); } } while(0);
-#define LOG_S(x); do { FILE *f; f=fopen("cmnav.log","a+"); if (f) { \
-   fprintf(f, "%s", x); fclose(f); } } while(0);
-#define ASSERT(x); if (!(x)) { LOG("ASSERT:"); LOG(#x); LOG("\n"); exit(-1); }
-#else
-#define LOG(x); ;
-#define LOG_S(x); ;
-#define ASSERT(x); ;
-#endif
-
-static char*
-getCurrWorkDir(char *buf, int maxLen)
-{
-#if defined WIN32
-    return _getcwd(buf, maxLen);
-#elif defined XP_UNIX
-    return getcwd(buf, maxLen);
-#else
-    return NULL;
-#endif
-}
-
-static void
-setWorkingDir(char *path)
-{
-#if defined WIN32
-    _chdir(path);
-#elif defined XP_UNIX
-    chdir(path);
-#else
-    return;
-#endif
-}
-
-static CMTStatus
-launch_psm(char *executable)
-{
-    char command[MAX_PATH_LEN];
-#ifdef WIN32
-    STARTUPINFO sui;
-    PROCESS_INFORMATION pi;
-    UNALIGNED long *posfhnd;
-    int i;
-    char *posfile;
-
-    sprintf(command,"%s > psmlog", executable);
-    ZeroMemory( &sui, sizeof(sui) );
-    sui.cb = sizeof(sui);
-    sui.cbReserved2 = (WORD)(sizeof( int ) + (3 * (sizeof( char ) + 
-                                                   sizeof( long ))));
-    sui.lpReserved2 = calloc( sui.cbReserved2, 1 );
-    *((UNALIGNED int *)(sui.lpReserved2)) = 3;
-    posfile = (char *)(sui.lpReserved2 + sizeof( int ));
-    posfhnd = (UNALIGNED long *)(sui.lpReserved2 + sizeof( int ) + 
-                                 (3 * sizeof( char )));
-    
-    for ( i = 0, posfile = (char *)(sui.lpReserved2 + sizeof( int )),
-              posfhnd = (UNALIGNED long *)(sui.lpReserved2 + sizeof( int ) + (3 * sizeof( char ))) ;
-          i < 3 ; i++, posfile++, posfhnd++ ) {
-        
-        *posfile = 0;
-        *posfhnd = (long)INVALID_HANDLE_VALUE;
-    }
-    /* Now, fire up PSM */
-    if (!CreateProcess(NULL, command, NULL, NULL, TRUE, DETACHED_PROCESS, 
-                       NULL, NULL, &sui, &pi)) {
-        goto loser;
-    }
-
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-#elif defined XP_UNIX
-    sprintf(command,"./%s &", executable);
-    if (system(command) == -1) {
-        goto loser;
-    }
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-#else
-    return CMTFailure;
-#endif
-}
-
-PCMT_CONTROL CMT_EstablishControlConnection(char            *inPath, 
-                                            CMT_SocketFuncs *sockFuncs,
-                                            CMT_MUTEX       *mutex)
-{
-    PCMT_CONTROL control;
-    char *executable;
-    char *newWorkingDir;
-    char oldWorkingDir[MAX_PATH_LEN];
-    int i;
-    char *path = NULL;
-    size_t stringLen;
-
-    /*	On the Mac, we do special magic in the Seamonkey PSM component, so
-    	if PSM isn't launched by the time we reach this point, we're not doing well. */
-#ifndef XP_MAC
-
-    struct stat stbuf;
-    
-    /*
-     * Create our own copy of path.
-     * I'd like to do a straight strdup here, but that caused problems
-     * for https.
-     */
-    stringLen = strlen(inPath);
-
-    path = (char*) malloc(stringLen+1);
-    memcpy(path, inPath, stringLen);
-    path[stringLen] = '\0';
-
-    control = CMT_ControlConnect(mutex, sockFuncs);
-    if (control != NULL) {
-        return control;
-    }
-    /*
-     * We have to try to launch it now, so it better be a valid 
-     * path.
-     */
-    if (stat(path, &stbuf) == -1) {
-        goto loser;
-    }
-    /*
-     * Now we have to parse the path and launch the psm server.
-     */
-    executable = strrchr(path, DIRECTORY_SEPARATOR);
-    if (executable != NULL) {
-        *executable = '\0';
-        executable ++;
-        newWorkingDir = path;
-    } else {
-        executable = path;
-        newWorkingDir = NULL;
-    }
-    if (getCurrWorkDir(oldWorkingDir, MAX_PATH_LEN) == NULL) {
-        goto loser;
-    }
-    setWorkingDir(newWorkingDir);
-    if (launch_psm(executable) != CMTSuccess) {
-        goto loser;
-    }
-    setWorkingDir(oldWorkingDir);
-#endif
-
-    /*
-     * Now try to connect to the psm server.  We will try to connect
-     * a maximum of 30 times and then give up.
-     */
-#ifdef WIN32
-    for (i=0; i<30; i++) {
-        Sleep(1000);
-        control = CMT_ControlConnect(mutex, sockFuncs);
-        if (control != NULL) {
-            break;
-        }
-    }
-#elif defined XP_UNIX
-    i = 0;
-    while (i<1000) {
-        i += sleep(10);
-	control = CMT_ControlConnect(mutex, sockFuncs);
-	if (control != NULL) {
-	  break;
-	}
-    }
-#elif defined(XP_MAC)
-	for (i=0; i<30; i++) 
-	{
-		EventRecord theEvent;
-		WaitNextEvent(0, &theEvent, 30, NULL);
-		control = CMT_ControlConnect(mutex, sockFuncs);
-		if (control != NULL) 
-			break;
-	}
-
-#else
-    /*
-     * Figure out how to sleep for a while first
-     */
-    for (i=0; i<30; i++) {
-      control = CMT_ControlConnect(mutex, sockFuncs);
-      if (control!= NULL) {
-	break;
-      }
-    }
-#endif
-    if (control == NULL) {
-        goto loser;
-    }
-    if (path) {
-        free (path);
-    }
-    return control;
- loser:
-    if (control != NULL) {
-        CMT_CloseControlConnection(control);
-    }
-    if (path) {
-        free(path);
-    }
-    return NULL;
-}
-
-
-PCMT_CONTROL CMT_ControlConnect(CMT_MUTEX *mutex, CMT_SocketFuncs *sockFuncs)
-{
-    PCMT_CONTROL control = NULL; 
-    CMTSocket sock=NULL;
-#ifdef XP_UNIX
-    int unixSock = 1;
-    char path[20];
-#else
-    int unixSock = 0;
-    char *path=NULL;
-#endif
-
-    if (sockFuncs == NULL) {
-        return NULL;
-    }
-#ifdef XP_UNIX
-    sprintf(path, "/tmp/.nsmc-%d", (int)geteuid());
-#endif    
-
-    sock = sockFuncs->socket(unixSock);
-    if (sock == NULL) {
-        LOG("Could not create a socket to connect to Control Connection.\n");
-        goto loser;
-    }
-    /* Connect to the psm process */
-    if (sockFuncs->connect(sock, CARTMAN_PORT, path)) {
-	  LOG("Could not connect to Cartman\n");
-	  goto loser;
-    }
-
-#ifdef XP_UNIX
-    if (sockFuncs->verify(sock) != CMTSuccess) {
-        goto loser;
-    }
-#endif
-
-	LOG("Connected to Cartman\n");
-	
-	/* fill in the CMTControl struct */
-	control = (PCMT_CONTROL)calloc(sizeof(CMT_CONTROL), 1);
-	if (control == NULL ) {
-		goto loser;
-	}
-	control->sock = sock;
-    if (mutex != NULL) {
-        control->mutex = (CMT_MUTEX*)calloc(sizeof(CMT_MUTEX),1);
-        if (control->mutex == NULL) {
-            goto loser;
-        }
-        *control->mutex = *mutex;
-    }
-    memcpy(&control->sockFuncs, sockFuncs, sizeof(CMT_SocketFuncs));
-    control->refCount = 1;
-	goto done;
-    
- loser:
-	if (control != NULL) {
-		free(control);
-    }
-    if (sock != NULL) {
-        sockFuncs->close(sock);
-    }
-	control = NULL;
-    
- done:
-	return control;
-}
-
-CMTStatus CMT_CloseControlConnection(PCMT_CONTROL control)
-{
-	/* XXX Don't know what to do here yet */
-    if (control != NULL) {
-        CMInt32 refCount;
-        CMT_LOCK(control->mutex);
-        control->refCount--;
-        refCount = control->refCount;
-        CMT_UNLOCK(control->mutex);
-        if (refCount <= 0) {
-            if (control->mutex != NULL) {
-                free (control->mutex);
-            }
-            control->sockFuncs.close(control->sock);
-            free(control);
-        }
-    }
-    
-	return CMTSuccess;
-}
-
-CMTStatus CMT_Hello(PCMT_CONTROL control, CMUint32 version, char* profile, 
-                    char* profileDir)
-{
-	CMTItem message;
-    PCMT_EVENT eventHandler;
-    CMBool doesUI;
-    HelloRequest request;
-    HelloReply reply;
-
-	/* Check the passed parameters */
-	if (!control) {
-		return CMTFailure;
-	}
-	if (!profile) {
-		return CMTFailure;
-	}
-    if (!profileDir) {
-        return CMTFailure;
-    }
-    
-	/* Create the hello message */
-    eventHandler = CMT_GetEventHandler(control, SSM_UI_EVENT, 0);
-    doesUI = (eventHandler == NULL) ? CM_FALSE : CM_TRUE;
-
-    /* Setup the request struct */
-    request.version = version;
-    request.policy = 0; /* no more policy */
-    request.doesUI = doesUI;
-    request.profile = profile;
-    request.profileDir = profileDir;
-
-    message.type = SSM_REQUEST_MESSAGE | SSM_HELLO_MESSAGE;
-
-    if (CMT_EncodeMessage(HelloRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-	/* Send the message and get the response */
-	if (CMT_SendMessage(control, &message) != CMTSuccess) {
-        goto loser;
-	}
-
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_HELLO_MESSAGE)) {
-        goto loser;
-    }
-
-    /* Decode the message */
-    if (CMT_DecodeMessage(HelloReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-	/* Successful response */
-	if (reply.result == 0) {
-            /* Save the nonce value */
-            control->sessionID = reply.sessionID;
-            control->protocolVersion = reply.version;
-            control->port = reply.httpPort;
-            control->nonce = reply.nonce;
-            control->policy = reply.policy;
-            control->serverStringVersion = reply.stringVersion;
-
-            /* XXX Free the messages */
-            return CMTSuccess;
-	}
-loser:
-	/* XXX Free the messages */
-	return CMTFailure;
-}
-
-CMTStatus CMT_PassAllPrefs(PCMT_CONTROL control, int num,
-                           CMTSetPrefElement* list)
-{
-    SetPrefListMessage request;
-    SingleNumMessage reply;
-    CMTItem message;
-
-    if ((control == NULL) || (list == NULL)) {
-        return CMTFailure;
-    }
-
-    /* pack the request */
-    request.length = num;
-    request.list = (SetPrefElement*)list;
-
-    if (CMT_EncodeMessage(SetPrefListMessageTemplate, &message, &request) !=
-        CMTSuccess) {
-        goto loser;
-    }
-    message.type = SSM_REQUEST_MESSAGE | SSM_PREF_ACTION;
-
-    /* send the message */
-    if (CMT_SendMessage(control, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_PREF_ACTION)) {
-        goto loser;
-    }
-
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) !=
-        CMTSuccess) {
-        goto loser;
-    }
-
-    /* don't really need to check the return value */
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-
-char* CMT_GetServerStringVersion(PCMT_CONTROL control)
-{
-    if (control == NULL) {
-        return NULL;
-    }
-    return control->serverStringVersion;
-}

mozilla/security/psm/lib/client/cmtjs.c

@@ -1,556 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include "cmtutils.h"
-#include "cmtjs.h"
-#include "messages.h"
-
-CMTStatus
-CMT_GenerateKeyPair(PCMT_CONTROL control, CMUint32 keyGenContext, 
-		    CMUint32 mechType, CMTItem *param, CMUint32 keySize, 
-		    CMUint32 *keyPairId)
-{
-    CMTItem message;
-    CMTStatus rv;
-    KeyPairGenRequest request = {0, 0, 0, {0, NULL, 0}};
-    SingleNumMessage reply;
-
-    if (!control) {
-        return CMTFailure;
-    }
-
-    request.keyGenCtxtID = keyGenContext;
-    request.genMechanism = mechType;
-    if (param) {
-        request.params = *param;
-    }
-    request.keySize = keySize;
-
-    /* Encode the message */
-    if (CMT_EncodeMessage(KeyPairGenRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    message.type = SSM_REQUEST_MESSAGE | SSM_PKCS11_ACTION | SSM_CREATE_KEY_PAIR;
-
-    /* Send the message and get the response */
-    rv = CMT_SendMessage(control, &message); 
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_PKCS11_ACTION | SSM_CREATE_KEY_PAIR)) {
-        goto loser;
-    }
-
-    /* Decode the message */
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-    *keyPairId = reply.value;
-    return CMTSuccess;
-    
-loser:
-    *keyPairId = 0;
-    return CMTFailure;
-}
-
-
-CMTStatus
-CMT_CreateNewCRMFRequest(PCMT_CONTROL control, CMUint32 keyPairID, 
-			 SSMKeyGenType keyGenType, CMUint32 *reqID)
-{
-    CMTItem message;
-    CMTStatus rv;
-    SingleNumMessage request;
-    SingleNumMessage reply;
-    
-    if (!control) {
-        return CMTFailure;
-    }
-
-    request.value = keyPairID;
-    if (CMT_EncodeMessage(SingleNumMessageTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    message.type = SSM_REQUEST_MESSAGE | SSM_CRMF_ACTION | 
-                    SSM_CREATE_CRMF_REQ;
-    rv = CMT_SendMessage(control, &message);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-  
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_CRMF_ACTION | SSM_CREATE_CRMF_REQ)) {
-        goto loser;
-    }
-
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *reqID = reply.value;
-
-    rv = CMT_SetNumericAttribute(control, *reqID, SSM_FID_CRMFREQ_KEY_TYPE,
-				 keyGenType);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus
-CMT_EncodeCRMFRequest(PCMT_CONTROL control, CMUint32 *crmfReqID, 
-		      CMUint32 numRequests, char ** der)
-{
-    CMTItem   message;
-    CMTStatus  rv;
-    EncodeCRMFReqRequest request;
-    SingleItemMessage reply;
-
-    if (!control) {
-        return CMTFailure;
-    }
-
-    request.numRequests = numRequests;
-    request.reqIDs = (long *) crmfReqID;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(EncodeCRMFReqRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    message.type = SSM_REQUEST_MESSAGE | SSM_CRMF_ACTION | SSM_DER_ENCODE_REQ;
-
-    rv = CMT_SendMessage(control, &message);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_CRMF_ACTION | SSM_DER_ENCODE_REQ)) {
-        goto loser;
-    }
-
-    /* XXX Should this be a string? Decode the message */
-    if (CMT_DecodeMessage(SingleItemMessageTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *der = (char *) reply.item.data;
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-
-CMTStatus
-CMT_ProcessCMMFResponse(PCMT_CONTROL control, char *nickname,
-			char *certRepString, CMBool doBackup,
-			void *clientContext)
-{
-    CMTItem   message;
-    CMTStatus  rv;
-    CMMFCertResponseRequest request;
-
-    if(!control) {
-        return CMTFailure;
-    }
-
-    request.nickname = nickname;
-    request.base64Der = certRepString;
-    request.doBackup = doBackup;
-    request.clientContext = CMT_CopyPtrToItem(clientContext);
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(CMMFCertResponseRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    message.type =  SSM_REQUEST_MESSAGE | SSM_CRMF_ACTION | SSM_PROCESS_CMMF_RESP;
-
-    rv = CMT_SendMessage(control, &message);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_CRMF_ACTION | SSM_PROCESS_CMMF_RESP)) {
-        goto loser;
-    }
-
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-
-CMTStatus
-CMT_CreateResource(PCMT_CONTROL control, SSMResourceType resType,
-		   CMTItem *params, CMUint32 *rsrcId, CMUint32 *errorCode)
-{
-    CMTItem message;
-    CMTStatus rv;
-    CreateResourceRequest request = {0, {0, NULL, 0}};
-    CreateResourceReply reply;
-
-    request.type = resType;
-    if (params) {
-        request.params = *params;
-    } 
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(CreateResourceRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | SSM_CREATE_RESOURCE;
-    
-    rv = CMT_SendMessage(control, &message);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | SSM_CREATE_RESOURCE)) {
-        goto loser;
-    }
-
-    /* Decode the message */
-    if (CMT_DecodeMessage(CreateResourceReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *rsrcId = reply.resID;
-    *errorCode = reply.result;
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_SignText(PCMT_CONTROL control, CMUint32 resID, char* stringToSign, char* hostName, char* caOption, CMInt32 numCAs, char** caNames)
-{
-    CMTItem message;
-    SignTextRequest request;
-
-    
-    /* So some basic parameter checking */
-    if (!control || !stringToSign) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.resID = resID;
-    request.stringToSign = stringToSign;
-    request.hostName = hostName;
-    request.caOption = caOption;
-    request.numCAs = numCAs;
-    request.caNames = caNames;
-
-    /* Encode the message */
-    if (CMT_EncodeMessage(SignTextRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_FORMSIGN_ACTION | SSM_SIGN_TEXT;
-
-    /* Send the message and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_FORMSIGN_ACTION | SSM_SIGN_TEXT)) {
-        goto loser;
-    }
-
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-
-CMTStatus
-CMT_ProcessChallengeResponse(PCMT_CONTROL control, char *challengeString,
-			     char **responseString)
-{
-    CMTItem   message;
-    CMTStatus  rv;
-    SingleStringMessage request;
-    SingleStringMessage reply;
-
-    /* Set the request */
-    request.string = challengeString;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(SingleStringMessageTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_CRMF_ACTION | SSM_CHALLENGE;
-
-    /* Send the message */
-    rv = CMT_SendMessage(control, &message);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-    
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_CRMF_ACTION | SSM_CHALLENGE)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(SingleStringMessageTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *responseString = reply.string;
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus
-CMT_FinishGeneratingKeys(PCMT_CONTROL control, CMUint32 keyGenContext)
-{
-    CMTItem message;
-    CMTStatus rv;
-    SingleNumMessage request;
-
-    /* Set up the request */
-    request.value = keyGenContext;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(SingleNumMessageTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_PKCS11_ACTION | SSM_FINISH_KEY_GEN;
-
-    /* Send the message */
-    rv = CMT_SendMessage(control, &message);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Validate the reply */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_PKCS11_ACTION | SSM_FINISH_KEY_GEN)) {
-        goto loser;
-    }
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus
-CMT_GetLocalizedString(PCMT_CONTROL        control,
-                       SSMLocalizedString  whichString,
-                       char              **localizedString)
-{
-    CMTItem message;
-    CMTStatus rv;
-    SingleNumMessage request;
-    GetLocalizedTextReply reply;
-
-    /* Set up the request */
-    request.value = whichString;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(SingleNumMessageTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_LOCALIZED_TEXT;
-
-    /* Send the message */
-    rv = CMT_SendMessage(control, &message);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_LOCALIZED_TEXT)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(GetLocalizedTextReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    if (reply.whichString != whichString) {
-        goto loser;
-    }
-    *localizedString = reply.localizedString;
-    return CMTSuccess;
- loser:
-    *localizedString = NULL;
-    return rv; 
-}
-
-CMTStatus
-CMT_AddNewModule(PCMT_CONTROL  control,
-                 char         *moduleName,
-                 char         *libraryPath,
-                 unsigned long pubMechFlags,
-                 unsigned long pubCipherFlags)
-{
-    CMTItem message;
-    CMTStatus rv;
-    AddNewSecurityModuleRequest request;
-    SingleNumMessage reply;
-
-    /* Set up the request */
-    request.moduleName = moduleName;
-    request.libraryPath = libraryPath;
-    request.pubMechFlags = pubMechFlags;
-    request.pubCipherFlags = pubCipherFlags;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(AddNewSecurityModuleRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_PKCS11_ACTION | SSM_ADD_NEW_MODULE;
-
-    /* Send the message */
-    rv = CMT_SendMessage(control, &message);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_PKCS11_ACTION | SSM_ADD_NEW_MODULE)) {
-        goto loser;
-    }
-
-    /* Decode the response */
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    return (CMTStatus) reply.value;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus
-CMT_DeleteModule(PCMT_CONTROL  control,
-                 char         *moduleName,
-                 int          *moduleType)
-{
-    CMTItem message;
-    CMTStatus rv;
-    SingleStringMessage request;
-    SingleNumMessage reply;
-
-    /* Set up the request */
-    request.string = moduleName;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(SingleStringMessageTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_PKCS11_ACTION | SSM_DEL_MODULE;
-
-    /* Send the message */
-    rv = CMT_SendMessage(control, &message);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_PKCS11_ACTION | SSM_DEL_MODULE)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *moduleType = reply.value;
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_LogoutAllTokens(PCMT_CONTROL control)
-{
-  CMTItem message;
-  CMTStatus rv;
-
-  message.type = SSM_REQUEST_MESSAGE | SSM_PKCS11_ACTION | SSM_LOGOUT_ALL;
-  message.data = NULL;
-  message.len  = 0;
-
-  rv = CMT_SendMessage(control, &message);
-  if (rv != CMTSuccess) {
-    return rv;
-  }
-  if (message.type !=  (SSM_REPLY_OK_MESSAGE | SSM_PKCS11_ACTION | 
-			SSM_LOGOUT_ALL)) {
-    return CMTFailure;
-  }
-  return CMTSuccess;
-}
-
-CMTStatus CMT_GetSSLCapabilities(PCMT_CONTROL control, CMInt32 *capabilites)
-{
-    SingleNumMessage reply;
-    CMTItem message;
-    CMTStatus rv;
-
-    message.type = (SSM_REQUEST_MESSAGE | SSM_PKCS11_ACTION | 
-                    SSM_ENABLED_CIPHERS);
-    message.data = NULL;
-    message.len  = 0;
-
-    rv = CMT_SendMessage(control, &message);
-
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_PKCS11_ACTION |
-			 SSM_ENABLED_CIPHERS)) {
-        goto loser;
-    }
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, 
-                          &message) != CMTSuccess) {
-        goto loser;
-    }
-    *capabilites = reply.value;
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}

mozilla/security/psm/lib/client/cmtjs.h

@@ -1,555 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifndef _CMTJS_H_
-#define _CMTJS_H_
-#include "cmtcmn.h"
-#include "ssmdefs.h"
-#include "rsrcids.h"
-/*
- * Define some constants.
- */
-
-/*
- * These defines are used in conjuction with the function
- * CMT_AddNewModule.
- */
-#define PUBLIC_MECH_RSA_FLAG         0x00000001ul
-#define PUBLIC_MECH_DSA_FLAG         0x00000002ul
-#define PUBLIC_MECH_RC2_FLAG         0x00000004ul
-#define PUBLIC_MECH_RC4_FLAG         0x00000008ul
-#define PUBLIC_MECH_DES_FLAG         0x00000010ul
-#define PUBLIC_MECH_DH_FLAG          0x00000020ul
-#define PUBLIC_MECH_FORTEZZA_FLAG    0x00000040ul
-#define PUBLIC_MECH_RC5_FLAG         0x00000080ul
-#define PUBLIC_MECH_SHA1_FLAG        0x00000100ul
-#define PUBLIC_MECH_MD5_FLAG         0x00000200ul
-#define PUBLIC_MECH_MD2_FLAG         0x00000400ul
- 
-#define PUBLIC_MECH_RANDOM_FLAG      0x08000000ul
-#define PUBLIC_MECH_FRIENDLY_FLAG    0x10000000ul
-#define PUBLIC_OWN_PW_DEFAULTS       0X20000000ul
-#define PUBLIC_DISABLE_FLAG          0x40000000ul
-
-
-/*
- * This is the lone supported constant for the Cipher flag
- * for CMT_AddNewModule
- */
-#define PUBLIC_CIPHER_FORTEZZA_FLAG  0x00000001ul
-
-CMT_BEGIN_EXTERN_C
-
-/*
- * FUNCTION: CMT_GenerateKeyPair
- * -----------------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    keyGenContext
- *        The Resource ID of a key gen context to use for creating the
- *        key pair.
- *    mechType
- *        A PKCS11 mechanism used to generate the key pair. Valid values are:
- *          CKM_RSA_PKCS_KEY_PAIR_GEN    0x00000000
- *          CKM_DSA_KEY_PAIR_GEN         0x00000010
- *        The definition of these values can be found at 
- *        http://www.rsa.com/rsalabs/pubs/pkcs11.html
- *        The psm module currently supports v2.01 of PKCS11
- *    params
- *        This parameter will be used to pass parameters to the Key Pair
- *        generation process.  Currently this feature is not supported, so 
- *        pass in NULL for this parameter.
- *    keySize
- *        The size (in bits) of the key to generate.
- *    keyPairId
- *        A pointer to pre-allocated memory where the function can place
- *        the value of the resource ID of the key pair that gets created.
- *
- * NOTES:
- * This function will send a message to the psm server requesting that 
- * a public/private key pair be generated. The key gen context will queue
- * the request. You can send as many key gen requests as you want with a
- * given key gen context. After sending all the key gen requests, the user
- * must call CMT_FinishGeneratingKeys so that the key gen context actually
- * generates the keys.
- *
- * RETURN:
- * A return value of CMTSuccess indicates the request for key generation
- * was queued successfully and the corresponding resource ID can be found
- * at *keyPairId.  Any other return value indicates an error and the value
- * at *keyPairId should be ignored.
- */
-CMTStatus
-CMT_GenerateKeyPair(PCMT_CONTROL control, CMUint32 keyGenContext, 
-		    CMUint32 mechType, CMTItem *params, CMUint32 keySize, 
-		    CMUint32 *keyPairId);
-
-/*
- * FUNCTION: CMT_FinishGeneratingKeys
- * ----------------------------------
- * INPUTS
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    keyGenContext
- *        The resource ID of the key gen context which should finish 
- *        generating its key pairs.
- * NOTES
- * This function will send a message to the psm server notifying the key 
- * gen context with the resource ID of keyGenContext to finish generating
- * all of the key gen requests it has queued up. After each key gen has 
- * finished, the psm server will send a SSM_TASK_COMPLETED_EVENT. So in order
- * to detect when all of the key gens are done, the user should register 
- * an event handler.  See comments for CMT_RegisterEventHandler for information
- * on how to successfully register event handler callbacks. You must register
- * the event handler with keyGenContext as the target resource ID for this
- * to work correctly.
- *
- * RETURN:
- * A return value of CMTSuccess indicates the key gen context has started to
- * generate the key pairs in its queue. Any other return value indicates an
- * error and the key pairs will not be generated.
- */
-CMTStatus
-CMT_FinishGeneratingKeys(PCMT_CONTROL control, CMUint32 keyGenContext);
-
-/*
- * FUNCTION: CMT_CreateNewCRMFRequest
- * ----------------------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    keyPairID
- *        The resource ID of the key pair that should be associated with
- *        the CRMF request created. At the time this function is called,
- *        key pair should have already been created. 
- *    keyGenType
- *        An enumeration that explains how the key pair will be used.
- *        Look at the definition of SSMKeyGenType in ssmdefs.h for valid
- *        values and their affects on the request.
- *    reqID
- *        A pointer to a pre-allocatd chunk of memory where the library 
- *        can place the resource ID of the new CRMF request.
- * NOTES:
- * This function sends a message to the psm server requesting that a new 
- * CRMF resource object be created. Each CRMF request must be associated with 
- * a public/private key pair, that is why the keyPairID parameter exists.
- * The keyGenType parameter is used to initialize the request, eg set the
- * correct keyUsage extension.
- * 
- * Before encoding a CRMF request, the user will want to set the appropriate
- * attributes to build up the request. The supported attributes are:
- *
- * Attribute Enumeration          Attribute Type       What value means
- * ---------------------          --------------       ----------------
- * SSM_FID_CRMFREQ_REGTOKEN       String               The value to encode as 
- *                                                     the registration token
- *                                                     value for the request.
- *
- * SSM_FID_CRMFREQ_AUTHENTICATOR String                The value to encode as
- *                                                     authenticator control
- *                                                     in the request.
- * 
- * SSM_FID_DN                    String                The RFC1485 formatted
- *                                                     DN to include in the
- *                                                     CRMF request.
- *
- * For information on how to properly set the attribute of a resource, refer
- * to the comments for the functions CMT_SetNumericAttribute and 
- * CMT_SetStringAttribute.
- *
- * RETURN:
- * A return value of CMTSuccess indicates a new CRMF resource was created by
- * the psm server and has the resource ID placed at *reqID. Any other return
- * value indicates an error and the value at *reqID should be ignored.
- */
-CMTStatus
-CMT_CreateNewCRMFRequest(PCMT_CONTROL control, CMUint32 keyPairID, 
-			 SSMKeyGenType keyGenType, CMUint32 *reqID);
-
-/*
- * FUNCTION: CMT_EncodeCRMFRequest
- * ------------------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    crmfReqID
- *        An array of resource ID's for CRMF objects to be encoded.
- *    numRequests
- *        The length of the array crmfReqID that is passed in.
- *    der
- *        A pointer to a pre-allocated pointer for a char* where the library
- *        can place the final DER-encoding of the requests.
- * NOTES
- * This function will send a message to the psm server requesting that 
- * a number of CRMF requests be encoded into their appropriate DER 
- * representation. The DER that is sent back will be of the type 
- * CertReqMessages as define in the internet draft for CRMF. To look at the
- * draft, visit the following URL: 
- * http://search.ietf.org/internet-drafts/internet-draft-ietf-pkix-crmf-01.txt
- *
- * RETURN:
- * A return value of CMTSuccess indicates psm successfully encoded the requests
- * and placed the base64 DER encoded request at *der. Any other return value
- * indicates an error and the value at *der should be ignored.
- */
-CMTStatus
-CMT_EncodeCRMFRequest(PCMT_CONTROL control, CMUint32 *crmfReqID, 
-		      CMUint32 numRequests, char ** der);
-
-/*
- * FUNCTION: CMT_ProcessCMMFResponse
- * ---------------------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    nickname
- *        The nickname that should be associated with the certificate 
- *        contained in the CMMF Response.
- *    certRepString
- *        This is the base 64 encoded CertRepContent that issues a certificate.
- *        The psm server will decode the base 64 data and then parse the
- *        CertRepContent.
- *    doBackup
- *        A boolean value indicating whether or not psm should initiate the
- *        process of backing up the newly issued certificate into a PKCS-12
- *        file.
- *    clientContext
- *         Client supplied data pointer that is returned to the client during
- *         a UI event.
- * NOTES:
- * This function takes a CertRepContent as defined in the CMMF internet draft
- * (http://search.ietf.org/internet-drafts/draft-ietf-pkix-cmmf-02.txt) and
- * imports the certificate into the user's database. The certificate will have
- * the string value of nickanme as it's nickname when added to the database
- * unless another certificate with that same Distinguished Name (DN) already
- * exists in the database, in which case the nickname of the certificate that
- * already exists will be used. If the value passed in for doBackup is 
- * non-zero, then the psm server will initiate the process of backing up the
- * certificate(s) that were just imported.
- *
- * RETURN:
- * A return value of CMTSuccess indicates the certificate(s) were successfully
- * added to the database. Any other return value means the certificate(s) could
- * not be successfully added to the database.
- */
-CMTStatus
-CMT_ProcessCMMFResponse(PCMT_CONTROL control, char *nickname, 
-			char *certRepString, CMBool doBackup,
-			void *clientContext);
-
-/*
- * FUNCTION: CMT_CreateResource
- * ----------------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    resType
- *        The enumeration representing the resource type to create.
- *    params
- *        A resource dependent binary string that will be sent to the psm 
- *        server. Each resource will expect a binary string it defines.
- *    rsrcId
- *        A pointer to a pre-allocated chunk of memory where the library
- *        can place the resource ID of the newly created resource.
- *    errorCode
- *        A pointer to a pre-allocated chunk of memory where the library
- *        can place the errorCode returned by the psm server after creating
- *        the resource.
- * NOTES:
- * This function sends a message to the psm server requesting that a new 
- * resource be created.  The params parameter depends on the type of resource
- * being created.  Below is a table detailing the format of the params for 
- * a given resource type. Only the resource types listed below can be created
- * by calling this function.
- *
- * Resource Type constant                  Value for params
- * ------------------------------          ----------------
- * SSM_RESTYPE_KEYGEN_CONTEXT              NULL
- * SSM_RESTYPE_SECADVISOR_CONTEXT          NULL
- * SSM_RESTYPE_SIGNTEXT                    NULL
- *
- * RETURN
- * A return value of CMTSuccess means the psm server received the request and
- * processed the create resource create. If the value at *errorCode is zero,
- * then the value at *rsrcId is the resource ID of the newly created resource.
- * Otherwise, creating the new resource failed and *errorCode contains the
- * error code returned by the psm server. ???What are the return values and
- * what do they mean. Any other return value indicates there was an error 
- * in the communication with the psm server and the values at *rsrcId and 
- * *errorCode should be ignored.
- */
-CMTStatus
-CMT_CreateResource(PCMT_CONTROL control, SSMResourceType resType,
-		   CMTItem *params, CMUint32 *rsrcId, CMUint32 *errorCode);
-
-/*
- * FUNCTION: CMT_SignText
- * ----------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    resID
- *        The resource ID of an SSMSignTextResource.
- *    stringToSign
- *        The string that the psm server should sign.
- *    hostName
- *        The host name of the site that is requesting a string to be
- *        signed.  This is used for displaying the UI that tells the user
- *        a web site has requested the use sign some text.
- *    caOption
- *        If the value is "auto" then psm will select the certificate
- *        to use for signing automatically.
- *        If the value is "ask" then psm will display a list of 
- *        certificates for signing.
- *    numCAs
- *        The number of CA names included in the array caNames passed in as
- *        the last parameter to this function.
- *    caNames
- *        An array of CA Names to use for filtering the user certs to use
- *        for signing the text.
- * NOTES
- * This function will sign the text passed via the parameter stringToSign.
- * The function will also cause the psm server to send some UI notifying the
- * user that a site has requested the user sign some text.  The hostName 
- * parameter is used in the UI to inform the user which site is requesting
- * the signed text.  The caOption is used to determine if the psm server 
- * should automatically select which personal cert to use in signing the
- * text.  The caNames array is ussed to narrow down the field of personal
- * certs to use when signing the text. In other words, only personal certs 
- * trusted by the CA's passed in will be used.
- *
- * RETURN
- * If the function returns CMTSuccess, that indicates the psm server 
- * successfully signed the text.  The signed text can be retrieved by 
- * calling CMT_GetStringResource and passing in SSM_FID_SIGNTEXT_RESULT
- * as the field ID. Any other return value indicates an error meaning the
- * string was not signed successfully.
- */
-CMTStatus
-CMT_SignText(PCMT_CONTROL control, CMUint32 resID, char* stringToSign,
-             char* hostName, char *caOption, CMInt32 numCAs, char** caNames);
-
-/*
- * FUNCTION: CMT_ProcessChallengeResponse
- * --------------------------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    challengeString
- *        The base64 encoded Challenge string received as the 
- *        Proof-Of-Possession Challenge in response to CRMF request that
- *        specified Challenge-Reponse as the method for Proof-Of-Possession.
- *    responseString
- *        A pointer to pre-allocated char* where the library can place a
- *        copy of the bas64 encoded response to the challenge presented.
- * NOTES
- * This function takes the a challenge--that is encrypted with the public key
- * of a certificate we created--and decrypts it with the private key we 
- * generated.  The format of the challenge is as follows:
- *
- * Challenge ::= SEQUENCE { 
- *      owf                 AlgorithmIdentifier  OPTIONAL, 
- *      -- MUST be present in the first Challenge; MAY be omitted in any 
- *      -- subsequent Challenge in POPODecKeyChallContent (if omitted, 
- *      -- then the owf used in the immediately preceding Challenge is 
- *      -- to be used). 
- *      witness             OCTET STRING, 
- *      -- the result of applying the one-way function (owf) to a 
- *      -- randomly-generated INTEGER, A.  [Note that a different 
- *      -- INTEGER MUST be used for each Challenge.] 
- *      sender              GeneralName, 
- *      -- the name of the sender. 
- *      key                 OCTET STRING, 
- *      -- the public key used to encrypt the challenge.  This will allow 
- *      -- the client to find the appropriate key to do the decryption. 
- *      challenge           OCTET STRING 
- *      -- the encryption (under the public key for which the cert. 
- *      -- request is being made) of Rand, where Rand is specified as 
- *      --   Rand ::= SEQUENCE { 
- *      --      int      INTEGER, 
- *      --       - the randomly-generated INTEGER A (above) 
- *      --      senderHash  OCTET STRING 
- *      --       - the result of applying the one-way function (owf) to 
- *      --       - the sender's general name 
- *      --   } 
- *      -- the size of "int" must be small enough such that "Rand" can be 
- *      -- contained within a single PKCS #1 encryption block. 
- *  } 
- * This challenge is based on the Challenge initially defined in the CMMF
- * internet draft, but differs in that this structure includes the sender
- * as part of the challenge along with the public key and includes a has
- * of the sender in the encrypted Rand structure.  The reason for including
- * the key is to facilitate looking up the key that should be used to 
- * decipher the challenge.  Including the hash of the sender in the encrypted
- * Rand structure makes the challenge smaller and allows it to fit in 
- * one RSA block. 
- *
- * The response is of the type POPODecKeyRespContent as defined in the CMMF
- * internet draft.
- *
- * RETURN
- * A return value of CMTSuccess indicates psm successfully parsed and processed
- * the challenge and created a response.  The base64 encoded response to the
- * challenge is placed at *responseString.  Any other return value indicates
- * an error and the value at *responseString should be ignored.
- */
-CMTStatus
-CMT_ProcessChallengeResponse(PCMT_CONTROL control, char *challengeString,
-			     char **responseString);
-
-/*
- * FUNCTION: CMT_GetLocalizedString
- * --------------------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    whichString
- *        The enumerated value corresponding to the localized string to 
- *        retrieve from the psm server
- *    localizedString
- *        A pointer to a pre-allocated char* where the library can place 
- *        copy of the localized string retrieved from the psm server.
- * NOTES
- * This function retrieves a localized string from the psm server.  These 
- * strings are useful for strings that aren't localized in the client 
- * making use of the psm server, but need to be displayed by the user. Look
- * in protocol.h for the enumerations of the localized strings that can 
- * be fetched from psm via this method.
- *
- * RETURN
- * A return value of CMTSuccess indicates the localized string was retrieved
- * successfully and the localized value is located at *localizedString.  Any
- * other return value indicates an error and the value at *localizedString
- * should be ignored.
- */
-CMTStatus 
-CMT_GetLocalizedString(PCMT_CONTROL        control, 
-                       SSMLocalizedString  whichString,
-                       char              **localizedString); 
-
-/*
- * FUNCTION: CMT_DeleteModule
- * --------------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    moduleName
- *        The name of the PKCS11 module to delete.
- *    moduleType
- *        A pointer to a pre-allocated integer where the library can place
- *        a value that tells what the type of module was deleted.
- * NOTES
- * This function will send a message to the psm server requesting the server 
- * delete a PKCS-11 module stored in psm's security module database. moduleName
- * is the value passed in as moduleName when the module was added to the 
- * security module database of psm.
- * The values that may be returned by psm for moduleType are:
- *
- *    0      The module was an external module developped by a third party
- *           that was added to the psm security module.
- *
- *    1      The module deleted was the internal PKCS-11 module that comes
- *           built in with the psm server.
- *
- *    2      The module that was deleted was the FIPS  internal module.
- *
- * RETURN
- * A return value of CMTSuccess indicates the security module was successfully
- * delete from the psm security module database and the value at *moduleType
- * will tell what type of module was deleted.
- * Any other return value indicates an error and the value at *moduleType 
- * should be ignored.
- */
-CMTStatus
-CMT_DeleteModule(PCMT_CONTROL  control,
-                 char         *moduleName,
-                 int          *moduleType);
-
-
-/*
- * FUNCTION: CMT_AddNewModule
- * --------------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    moduleName
- *        The name to be associated with the module once it is added to 
- *        the psm security module database.
- *    libraryPath
- *        The path to the library to be  loaded.  The library should be 
- *        loadable at run-time.
- *    pubMechFlags
- *        A bit vector indicating all cryptographic mechanisms that should
- *        be turned on by default.  This module will become the default 
- *        handler for the mechanisms that are set by this bit vector.
- *    pubCipherFlags
- *        A bit vector indicating all SSL or S/MIME cipher functions
- *        supported by the module. Most modules will pas in 0x0 for this
- *        parameter.
- * NOTES:
- * This function sends a message to the psm server and requests the .so
- * file on UNIX or .dll file on Windows be loaded as a PKCS11 module and 
- * be stored in the psm security module database.  The module will be stored
- * with the name moduleName that is passed in and will always expect the 
- * library to live at the path passed in via the parameter libraryPath.
- * The pubMechFlags tell the psm server how this module should be used.
- * Valid values are the #define constants defined at the beginning of
- * this file.
- * 
- * RETURN
- * A return value of CMTSuccess indicates the module was successfully loaded
- * and placed in the security module database of psm.  Any other return value
- * indicates an error and means the module was not loaded successfully and
- * not stored in the psm server's security module database.
- */
-CMTStatus
-CMT_AddNewModule(PCMT_CONTROL  control,
-                 char         *moduleName,
-                 char         *libraryPath,
-                 unsigned long pubMechFlags,
-                 unsigned long pubCipherFlags);
-
-CMT_END_EXTERN_C
-
-#endif /*_CMTJS_H_*/

mozilla/security/psm/lib/client/cmtmac.c

@@ -1,75 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-
-#include "cmtmac.h"
-#include "macsocket.h"
-#include "stdlib.h"
-
-#ifndef XP_MAC
-#error Link with the builtin strdup() on your platform.
-#endif
-
-
-static void 
-my_strcpy(char *dest, const char *source)
-{
-	char *i = dest;
-	const char *j = source;
-	while(*j)
-		*i++ = *j++;
-	*i = '\0';
-}
-
-static int
-my_strlen(const char *str)
-{
-	const char *c = str;
-	int i = 0;
-	
-	while(*c++ != '\0')
-		i++;
-	return i;
-}
-
-char * strdup(const char *oldstr)
-{
-	/* used to keep the mac client library from referring to strdup elsewhere */
-	char *newstr;
-	
-	newstr = (char *) malloc(my_strlen(oldstr)+1);
-	if (newstr)
-		my_strcpy(newstr, oldstr);
-	return newstr;
-}
-

mozilla/security/psm/lib/client/cmtmac.h

@@ -1,40 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-
-#ifndef __CMTMAC_H__
-#define __CMTMAC_H__
-
-char * strdup(const char *str);
-
-#endif

mozilla/security/psm/lib/client/cmtpasswd.c

@@ -1,119 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-/************************************************************************
- * Code to handle password requests from the the PSM module.
- * 
- ************************************************************************
- */
-
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "messages.h"
-
-void CMT_SetAppFreeCallback(PCMT_CONTROL control, 
-			    applicationFreeCallback_fn f)
-{
-  control->userFuncs.userFree = f;
-}
-    
-void CMT_ServicePasswordRequest(PCMT_CONTROL cm_control, CMTItem * requestData)
-{ 
-  CMTItem response = {0, NULL, 0};
-  PasswordRequest request;
-  PasswordReply reply;
-  void * clientContext;
-
-  /********************************************
-   *  What we trying to do here: 
-   *  1) Throw up a dialog box and request a password.
-   *  2) Create a message and send it to the PSM module.
-   ********************************************
-   */
-  
-  /* Decode the request */
-  if (CMT_DecodeMessage(PasswordRequestTemplate, &request, requestData) != CMTSuccess) {
-      goto loser;
-  }
-
-  /* Copy the client context to a pointer */
-  clientContext = CMT_CopyItemToPtr(request.clientContext);
-
-  if (cm_control->userFuncs.promptCallback == NULL) {
-      goto loser;
-  }
-  reply.passwd = 
-    cm_control->userFuncs.promptCallback(cm_control->userFuncs.promptArg, 
-					 request.prompt, clientContext, 1);
-  reply.tokenID = request.tokenKey;
-  if (!reply.passwd) {
-      /* the user cancelled the prompt or other errors occurred */
-      reply.result = -1;
-  }
-  else {
-      /* note that this includes an empty string (zero length password) */
-      reply.result = 0;
-  }
-
-  /* Encode the reply */
-  if (CMT_EncodeMessage(PasswordReplyTemplate, &response, &reply) != CMTSuccess) {
-      goto loser;
-  }
-
-  /* Set the message response type */
-  response.type = SSM_EVENT_MESSAGE | SSM_AUTH_EVENT;
-  CMT_TransmitMessage(cm_control, &response);
-  goto done;
-loser:
-  /* something has gone wrong */
-
-done:
-  /*clean up anyway */
-  /* We can't just free up memory allocated by the host
-     application because the versions of free may not match up.
-     When you run the plug-in with an optimized older browser,
-     you'll see tons of Asserts (why they still have asserts in an
-     optimized build is a different question, but without them 
-     I wouldn't have figured out this problem) about a pointer not
-     being a valid heap pointer and eventually crash.  This was 
-     the offending free line.
-     So we need to call a function within the browser that 
-     calls the free linked in with it.  js_free is
-     such a function.  But this is extremely ugly.
-   */
-  if (reply.passwd) 
-    cm_control->userFuncs.userFree(reply.passwd);
-  if (request.prompt) 
-    free(request.prompt);
-  return;
-}
-

mozilla/security/psm/lib/client/cmtpkcs7.c

@@ -1,636 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifdef XP_UNIX
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <sys/time.h>
-#else
-#ifdef XP_MAC
-#include "macsocket.h"
-#else /* Windows */
-#include <windows.h>
-#include <winsock.h>
-#endif
-#endif
-#include <errno.h>
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "messages.h"
-#include "rsrcids.h"
-
-typedef struct _CMTP7Private {
-    CMTPrivate priv;
-    CMTP7ContentCallback cb;
-    void *cb_arg;
-} CMTP7Private;
-
-CMTStatus CMT_PKCS7DecoderStart(PCMT_CONTROL control, void* clientContext, CMUint32 * connectionID, CMInt32 * result,
-                                CMTP7ContentCallback cb, void *cb_arg)
-{
-    CMTItem message;
-    CMTStatus rv;
-    CMTP7Private *priv=NULL;
-    SingleItemMessage request;
-    DataConnectionReply reply;
-
-    /* Check passed in parameters */
-    if (!control) {
-        goto loser;
-    }
-
-    request.item = CMT_CopyPtrToItem(clientContext);
-
-    /* Encode message */
-    if (CMT_EncodeMessage(SingleItemMessageTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_DATA_CONNECTION | SSM_PKCS7DECODE_STREAM;
-
-    /* Send the message. */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_DATA_CONNECTION | SSM_PKCS7DECODE_STREAM)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(DataConnectionReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Success */
-    if (reply.result == 0) {
-        CMTSocket sock;
-
-        priv = (CMTP7Private *)malloc(sizeof(CMTP7Private));
-        if (priv == NULL)
-            goto loser;
-        priv->priv.dest = (CMTReclaimFunc) free;
-        priv->cb = cb;
-        priv->cb_arg = cb_arg;
-        sock = control->sockFuncs.socket(0);
-        if (sock == NULL) {
-            goto loser;
-        }
- 
-       if (control->sockFuncs.connect(sock, (short)reply.port, 
-                                      NULL) != CMTSuccess) {
-            goto loser;
-        }
- 
-        if (control->sockFuncs.send(sock, control->nonce.data, 
-                                    control->nonce.len) != control->nonce.len){
-            goto loser;
-        }
-
-        /* Save connection info */
-        if (CMT_AddDataConnection(control, sock, reply.connID)
-            != CMTSuccess) {
-            goto loser;
-        }
-        *connectionID = reply.connID;
-
-        rv = CMT_SetPrivate(control, reply.connID, &priv->priv);
-        if (rv != CMTSuccess)
-            goto loser;
-
-        return CMTSuccess;
-    } 
-
-loser:
-    if (priv) {
-        free(priv);
-    }
-
-	*result = reply.result;
-    return CMTFailure;
-}
-
-CMTStatus CMT_PKCS7DecoderUpdate(PCMT_CONTROL control, CMUint32 connectionID, const char * buf, CMUint32 len)
-{
-    CMUint32 sent;
-    CMTP7Private *priv;
-    unsigned long nbytes;
-    char read_buf[128];
-    CMTSocket sock, ctrlsock, selSock, sockArr[2];
-
-    /* Do some parameter checking */
-    if (!control || !buf) {
-        goto loser;
-    }
-
-    /* Get the data socket */
-    if (CMT_GetDataSocket(control, connectionID, &sock) == CMTFailure) {
-        goto loser;
-    }
-
-    priv = (CMTP7Private *)CMT_GetPrivate(control, connectionID);
-    if (priv == NULL)
-        goto loser;
-
-    /* Write the data to the socket */
-    sent = CMT_WriteThisMany(control, sock, (void*)buf, len);
-    if (sent != len) {
-        goto loser;
-    }
-
-	ctrlsock = control->sock;
-	sockArr[0] = ctrlsock;
-	sockArr[1] = sock;
-    while ((selSock = control->sockFuncs.select(sockArr,2,1))) 
-    {
-		if (selSock == ctrlsock) {
-			CMT_ProcessEvent(control);
-		} else {
-	        nbytes = control->sockFuncs.recv(sock, read_buf, sizeof(read_buf));
-		    if (nbytes == -1) {
-			    goto loser;
-			}
-			if (nbytes == 0) {
-	            break;
-		    }
-			priv->cb(priv->cb_arg, read_buf, nbytes);
-		}
-    }
-
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-                                                                                
-CMTStatus CMT_PKCS7DecoderFinish(PCMT_CONTROL control, CMUint32 connectionID, 
-                                 CMUint32 * resourceID)
-{
-    CMTP7Private *priv;
-    long nbytes;
-    char buf[128];
-    CMTSocket sock, ctrlsock, selSock, sockArr[2];
-
-    /* Do some parameter checking */
-    if (!control) {
-        goto loser;
-    }
-
-    priv = (CMTP7Private *)CMT_GetPrivate(control, connectionID);
-    if (priv == NULL)
-        goto loser;
-
-    if (CMT_GetDataSocket(control, connectionID, &sock) == CMTFailure) {
-        goto loser;
-    }
-
-    ctrlsock = control->sock;
-    /* drain socket before we close it */
-    control->sockFuncs.shutdown(sock);
-    sockArr[0] = sock;
-    sockArr[1] = ctrlsock;
-    /* Let's see if doing a poll first gets rid of a weird bug where we
-     * lock up the client.
-     */
-#ifndef XP_MAC
-    if (control->sockFuncs.select(sockArr,2,1) != NULL)
-#endif
-	{
-        while (1) {
-            selSock = control->sockFuncs.select(sockArr,2,0);
-            if (selSock == ctrlsock) {
-                CMT_ProcessEvent(control);
-            } else if (selSock == sock) {
-                nbytes = control->sockFuncs.recv(sock, buf, sizeof(buf));
-                if (nbytes < 0) {
-                    goto loser;
-                } else if (nbytes == 0) {
-                    break;
-                }
-                priv->cb(priv->cb_arg, buf, nbytes);
-            }
-        }
-    }
-    
-    if (CMT_CloseDataConnection(control, connectionID) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Get the PKCS7 content info */
-    if (CMT_GetRIDAttribute(control, connectionID, SSM_FID_P7CONN_CONTENT_INFO,
-                            resourceID) == CMTFailure) {
-        goto loser;
-    }
-
-    return CMTSuccess;
-
-loser:
-    if (control) {
-        CMT_CloseDataConnection(control, connectionID);
-    }
-    
-    return CMTFailure;
-}
-
-CMTStatus CMT_PKCS7DestroyContentInfo(PCMT_CONTROL control, CMUint32 resourceID)
-{
-    if (!control) {
-        goto loser;
-    }
-
-    /* Delete the resource */
-    if (CMT_DestroyResource(control, resourceID, SSM_FID_P7CONN_CONTENT_INFO) == CMTFailure) {
-        goto loser;
-    }
-    return CMTSuccess;
-
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_PKCS7VerifyDetachedSignature(PCMT_CONTROL control, CMUint32 resourceID, CMUint32 certUsage, CMUint32 hashAlgID, CMUint32 keepCerts, CMTItem* digest, CMInt32 * result)
-{
-    CMTItem message;
-    VerifyDetachedSigRequest request;
-    SingleNumMessage reply;
-
-    /* Do some parameter checking */
-    if (!control || !digest || !result) {
-        goto loser;
-    }
-
-    /* Set the request */
-    request.pkcs7ContentID = resourceID;
-    request.certUsage = certUsage;
-    request.hashAlgID = hashAlgID;
-    request.keepCert = (CMBool) keepCerts;
-    request.hash = *digest;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(VerifyDetachedSigRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_OBJECT_SIGNING | SSM_VERIFY_DETACHED_SIG;
-
-    /* Send the message */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_OBJECT_SIGNING |SSM_VERIFY_DETACHED_SIG)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *result = reply.value;
-    return CMTSuccess;
-loser:
-	*result = reply.value;
-	return CMTFailure;
-}
-
-CMTStatus CMT_PKCS7VerifySignature(PCMT_CONTROL control, CMUint32 pubKeyAlgID,
-                                   CMTItem *pubKeyParams, CMTItem *signerPubKey,
-                                   CMTItem *computedHash, CMTItem *signature,
-                                   CMInt32 *result)
-{
-	return CMTFailure;
-}
-
-CMTStatus CMT_CreateSigned(PCMT_CONTROL control, CMUint32 scertRID,
-                           CMUint32 ecertRID, CMUint32 dig_alg,
-                           CMTItem *digest, CMUint32 *ciRID, CMInt32 *errCode)
-{
-    CMTItem message;
-    CreateSignedRequest request;
-    CreateContentInfoReply reply;
-
-    /* Do some parameter checking */
-    if (!control || !scertRID || !ecertRID || !digest || !ciRID) {
-        goto loser;
-    }
-
-    /* Set the request */
-    request.scertRID = scertRID;
-    request.ecertRID = ecertRID;
-    request.dig_alg = dig_alg;
-    request.digest = *digest;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(CreateSignedRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_OBJECT_SIGNING | SSM_CREATE_SIGNED;
-
-    /* Send the message */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_OBJECT_SIGNING | SSM_CREATE_SIGNED)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(CreateContentInfoReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *ciRID = reply.ciRID;
-    if (reply.result == 0) {
-		return CMTSuccess;
-	} 
-
-loser:
-    if (CMT_DecodeMessage(CreateContentInfoReplyTemplate, &reply, &message) == CMTSuccess) {
-        *errCode = reply.errorCode;
-    } else {
-        *errCode = 0;
-    }
-	return CMTFailure;
-}
-
-CMTStatus CMT_CreateEncrypted(PCMT_CONTROL control, CMUint32 scertRID,
-                              CMUint32 *rcertRIDs, CMUint32 *ciRID)
-{
-    CMTItem message;
-    CMInt32 nrcerts;
-    CreateEncryptedRequest request;
-    CreateContentInfoReply reply;
-
-    /* Do some parameter checking */
-    if (!control || !scertRID || !rcertRIDs || !ciRID) {
-        goto loser;
-    }
-
-    /* Calculate the number of certs */
-    for (nrcerts =0; rcertRIDs[nrcerts] != 0; nrcerts++) {
-        /* Nothing */
-        ;
-    }
-
-    /* Set up the request */
-    request.scertRID = scertRID;
-    request.nrcerts = nrcerts;
-    request.rcertRIDs = (long *) rcertRIDs;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(CreateEncryptedRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_OBJECT_SIGNING | SSM_CREATE_ENCRYPTED;
-
-    /* Send the message */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message response type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_OBJECT_SIGNING | SSM_CREATE_ENCRYPTED)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(CreateContentInfoReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *ciRID = reply.ciRID;
-    if (reply.result == 0) {
-		return CMTSuccess;
-	} 
-loser:
-	return CMTFailure;
-}
-
-CMTStatus CMT_PKCS7EncoderStart(PCMT_CONTROL control, CMUint32 ciRID,
-                                CMUint32 *connectionID, CMTP7ContentCallback cb,
-                                void *cb_arg)
-{
-    CMTItem message;
-    CMTStatus rv;
-    CMTP7Private *priv;
-    PKCS7DataConnectionRequest request;
-    DataConnectionReply reply;
-
-    /* Check passed in parameters */
-    if (!control || !ciRID) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.resID = ciRID;
-    request.clientContext.len = 0;
-    request.clientContext.data = NULL;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(PKCS7DataConnectionRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_DATA_CONNECTION | SSM_PKCS7ENCODE_STREAM;
-
-    /* Send the message */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_DATA_CONNECTION | SSM_PKCS7ENCODE_STREAM)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(DataConnectionReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Success */
-    if (reply.result == 0) {
-        CMTSocket sock;
-
-        priv = (CMTP7Private *)malloc(sizeof(CMTP7Private));
-        if (priv == NULL)
-            goto loser;
-        priv->priv.dest = (CMTReclaimFunc) free;
-        priv->cb = cb;
-        priv->cb_arg = cb_arg;
-
-        sock = control->sockFuncs.socket(0);
-        if (sock == NULL) {
-            goto loser;
-        }
-        if (control->sockFuncs.connect(sock, (short)reply.port, 
-                                       NULL) != CMTSuccess) {
-            goto loser;
-        }
-        if (control->sockFuncs.send(sock, control->nonce.data, 
-                                   control->nonce.len) != control->nonce.len) {
-            goto loser;
-        }
-        /* Save connection info */
-        if (CMT_AddDataConnection(control, sock, reply.connID)
-            != CMTSuccess) {
-            goto loser;
-        }
-        *connectionID = reply.connID;
-
-        rv = CMT_SetPrivate(control, reply.connID, &priv->priv);
-        if (rv != CMTSuccess)
-            goto loser;
-        return CMTSuccess;
-    } 
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_PKCS7EncoderUpdate(PCMT_CONTROL control, CMUint32 connectionID,
-                                 const char *buf, CMUint32 len)
-{
-    CMUint32 sent;
-    CMTP7Private *priv;
-    unsigned long nbytes;
-    char read_buf[128];
-    CMTSocket sock, ctrlsock, sockArr[2], selSock;
-
-    /* Do some parameter checking */
-    if (!control || !connectionID || !buf) {
-        goto loser;
-    }
-
-    /* Get the data socket */
-    if (CMT_GetDataSocket(control, connectionID, &sock) == CMTFailure) {
-        goto loser;
-    }
-
-    priv = (CMTP7Private *)CMT_GetPrivate(control, connectionID);
-    if (priv == NULL)
-        goto loser;
-
-    /* Write the data to the socket */
-    sent = CMT_WriteThisMany(control, sock, (void*)buf, len);
-    if (sent != len) {
-        goto loser;
-    }
-	ctrlsock = control->sock;
-	sockArr[0] = ctrlsock;
-	sockArr[1] = sock;
-    while ((selSock = control->sockFuncs.select(sockArr, 2, 1)) != NULL) 
-    {
-		if (selSock == ctrlsock) {
-			CMT_ProcessEvent(control);
-		} else {
-	        nbytes = control->sockFuncs.recv(sock, read_buf, sizeof(read_buf));
-		    if (nbytes == -1) {
-			    goto loser;
-			} else if (nbytes == 0) {
-	            break;
-		    } else {
-			    priv->cb(priv->cb_arg, read_buf, nbytes);
-			}
-		}
-    }
-    return CMTSuccess;
-
-loser:
-
-    return CMTFailure;
-}
-
-CMTStatus CMT_PKCS7EncoderFinish(PCMT_CONTROL control, CMUint32 connectionID)
-{
-    CMTP7Private *priv;
-    unsigned long nbytes;
-    char buf[128];
-    CMTSocket sock, ctrlsock, sockArr[2], selSock;
-
-    /* Do some parameter checking */
-    if (!control) {
-        goto loser;
-    }
-
-    priv = (CMTP7Private *)CMT_GetPrivate(control, connectionID);
-    if (priv == NULL)
-        goto loser;
-
-    if (CMT_GetDataSocket(control, connectionID, &sock) == CMTFailure) {
-        goto loser;
-    }
-
-    ctrlsock = control->sock;
-    sockArr[0] = ctrlsock;
-    sockArr[1] = sock;
-    control->sockFuncs.shutdown(sock);
-    while (1) {
-        selSock = control->sockFuncs.select(sockArr, 2, 0);
-        if (selSock == ctrlsock) {
-            CMT_ProcessEvent(control);
-        } else if (selSock == sock) {
-            nbytes = control->sockFuncs.recv(sock, buf, sizeof(buf));
-            if (nbytes < 0) {
-                goto loser;
-            } else if (nbytes == 0) {
-                break;
-            } else {
-                priv->cb(priv->cb_arg, buf, nbytes);
-            }
-        }
-    }
-    if (CMT_CloseDataConnection(control, connectionID) == CMTFailure) {
-        goto loser;
-    }
-
-    return CMTSuccess;
-
-loser:
-    if (control) {
-        CMT_CloseDataConnection(control, connectionID);
-    }
-    
-    return CMTFailure;
-}

mozilla/security/psm/lib/client/cmtres.c

@@ -1,479 +0,0 @@
-/* -*- mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifdef XP_UNIX
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#else
-#ifdef XP_MAC
-#include "macsocket.h"
-#else
-#include <windows.h>
-#include <winsock.h>
-#endif
-#endif
-#include <errno.h>
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "messages.h"
-#include <string.h>
-
-CMTStatus CMT_GetNumericAttribute(PCMT_CONTROL control, CMUint32 resourceID, CMUint32 fieldID, CMInt32 *value)
-{
-    CMTItem message;
-    GetAttribRequest request;
-    GetAttribReply reply;
-
-    /* Do some parameter checking */
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.resID = resourceID;
-    request.fieldID = fieldID;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(GetAttribRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | SSM_GET_ATTRIBUTE | SSM_NUMERIC_ATTRIBUTE;
-
-    /* Send the mesage and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | SSM_GET_ATTRIBUTE | SSM_NUMERIC_ATTRIBUTE)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(GetAttribReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *value = reply.value.u.numeric;
-
-    /* Success */
-    if (reply.result == 0) {
-        return CMTSuccess;
-    } 
-
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_SetNumericAttribute(PCMT_CONTROL control, CMUint32 resourceID,
-				  CMUint32 fieldID, CMInt32 value)
-{
-    CMTItem message;
-    SetAttribRequest request;
-
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set the request */
-    request.resID = resourceID;
-    request.fieldID = fieldID;
-    request.value.type = SSM_NUMERIC_ATTRIBUTE;
-    request.value.u.numeric = value;
-
-    /* Encode the message */
-    if (CMT_EncodeMessage(SetAttribRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | 
-                   SSM_SET_ATTRIBUTE | SSM_NUMERIC_ATTRIBUTE;
-
-    if (CMT_SendMessage(control, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | 
-                              SSM_SET_ATTRIBUTE    | SSM_NUMERIC_ATTRIBUTE)) {
-        goto loser;
-    }
-
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus
-CMT_PadStringValue(CMTItem *dest, CMTItem src)
-{
-    dest->data = NewArray(unsigned char, src.len+1);
-    if (dest->data == NULL) {
-        return CMTFailure;
-    }
-    memcpy(dest->data, src.data, src.len);
-    dest->data[src.len] = '\0';
-    dest->len = src.len;
-    free(src.data);
-    return CMTSuccess;
-}
-
-CMTStatus CMT_GetStringAttribute(PCMT_CONTROL control, CMUint32 resourceID, CMUint32 fieldID, CMTItem *value)
-{
-    CMTItem message;
-    GetAttribRequest request;
-    GetAttribReply reply;
-
-    /* Do some parameter checking */
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.resID = resourceID;
-    request.fieldID = fieldID;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(GetAttribRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | SSM_GET_ATTRIBUTE | SSM_STRING_ATTRIBUTE;
-    
-    /* Send the mesage and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | SSM_GET_ATTRIBUTE | SSM_STRING_ATTRIBUTE)) {
-        goto loser;
-    }
-
-    /* Decode the response */
-    if (CMT_DecodeMessage(GetAttribReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Success */
-    if (reply.result == 0) {
-        return CMT_PadStringValue(value, reply.value.u.string);
-    } 
-loser:
-    return CMTFailure;
-}
-
-CMTStatus
-CMT_SetStringAttribute(PCMT_CONTROL control, CMUint32 resourceID,
-		       CMUint32 fieldID, CMTItem *value)
-{
-    CMTItem message;
-    SetAttribRequest request;
-    
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.resID = resourceID;
-    request.fieldID = fieldID;
-    request.value.type = SSM_STRING_ATTRIBUTE;
-    request.value.u.string = *value;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(SetAttribRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | 
-                   SSM_SET_ATTRIBUTE | SSM_STRING_ATTRIBUTE;
-
-    /* Send the message */
-    if (CMT_SendMessage(control, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Validate the message request type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | 
-                         SSM_SET_ATTRIBUTE    | SSM_STRING_ATTRIBUTE)) {
-        goto loser;
-    }
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_DuplicateResource(PCMT_CONTROL control, CMUint32 resourceID,
-				CMUint32 *newResID)
-{
-    CMTItem message;
-    SingleNumMessage request;
-    DupResourceReply reply;
-
-    /* Do some parameter checking */
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.value = resourceID;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(SingleNumMessageTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | SSM_DUPLICATE_RESOURCE;
-
-    /* Send the mesage */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | SSM_DUPLICATE_RESOURCE)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(DupResourceReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Success */
-    if (reply.result == 0) {
-        *newResID = reply.resID;
-        return CMTSuccess;
-    } 
-
-loser:
-    *newResID = 0;
-    return CMTFailure;
-}
-
-CMTStatus CMT_DestroyResource(PCMT_CONTROL control, CMUint32 resourceID, CMUint32 resourceType)
-{
-    CMTItem message;
-    DestroyResourceRequest request;
-    SingleNumMessage reply;
-
-    /* Do some parameter checking */
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.resID = resourceID;
-    request.resType = resourceType;
-
-    /* Encode the message */
-    if (CMT_EncodeMessage(DestroyResourceRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | SSM_DESTROY_RESOURCE;
-
-    /* Send the message */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | SSM_DESTROY_RESOURCE)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Success */
-    if (reply.value == 0) {
-        return CMTSuccess;
-    }
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_PickleResource(PCMT_CONTROL control, CMUint32 resourceID, CMTItem * pickledResource)
-{
-    CMTItem message;
-    SingleNumMessage request;
-    PickleResourceReply reply;
-
-    /* Do some parameter checking */
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.value = resourceID;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(SingleNumMessageTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | SSM_CONSERVE_RESOURCE | SSM_PICKLE_RESOURCE;
-
-    /* Send the mesage and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | SSM_CONSERVE_RESOURCE | SSM_PICKLE_RESOURCE)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(PickleResourceReplyTemplate, &reply,&message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Success */
-    if (reply.result == 0) {
-        *pickledResource = reply.blob;
-        return CMTSuccess;
-    } 
-
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_UnpickleResource(PCMT_CONTROL control, CMUint32 resourceType, CMTItem pickledResource, CMUint32 * resourceID)
-{
-    CMTItem message;
-    UnpickleResourceRequest request;
-    UnpickleResourceReply reply;
-
-    /* Do some parameter checking */
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.resourceType = resourceType;
-    request.resourceData = pickledResource;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(UnpickleResourceRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | SSM_CONSERVE_RESOURCE | SSM_UNPICKLE_RESOURCE;
-    
-    /* Send the mesage and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | SSM_CONSERVE_RESOURCE | SSM_UNPICKLE_RESOURCE)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(UnpickleResourceReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Success */
-    if (reply.result == 0) {
-        *resourceID = reply.resID;
-        return CMTSuccess;
-    } 
-
-loser:
-    *resourceID = 0;
-    return CMTFailure;
-}
-
-CMTStatus CMT_GetRIDAttribute(PCMT_CONTROL control, CMUint32 resourceID, CMUint32 fieldID, CMUint32 *value)
-{
-    CMTItem message;
-    GetAttribRequest request;
-    GetAttribReply reply;
-
-    /* Do some parameter checking */
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set the request */
-    request.resID = resourceID;
-    request.fieldID = fieldID;
-
-    /* Encode the message */
-    if (CMT_EncodeMessage(GetAttribRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | SSM_GET_ATTRIBUTE | SSM_RID_ATTRIBUTE;
-
-    /* Send the mesage and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message response type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | SSM_GET_ATTRIBUTE | SSM_RID_ATTRIBUTE)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(GetAttribReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Success */
-    if (reply.result == 0) {
-        *value = reply.value.u.rid;
-        return CMTSuccess;
-    } 
-loser:
-    return CMTFailure;
-}
- 

mozilla/security/psm/lib/client/cmtrng.c

@@ -1,270 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-/*
-  cmtrng.c -- Support for PSM random number generator and the seeding
-              thereof with data from the client.
-
-  Created by mwelch 1999 Oct 21
- */
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "messages.h"
-#include "rsrcids.h"
-#include <string.h>
-
-CMTStatus
-CMT_EnsureInitializedRNGBuf(PCMT_CONTROL control)
-{
-    if (control->rng.outBuf == NULL)
-    {
-        control->rng.outBuf = (char *) calloc(RNG_OUT_BUFFER_LEN, sizeof(char));
-        if (control->rng.outBuf == NULL)
-            goto loser;
-
-        control->rng.validOutBytes = 0;
-        control->rng.out_cur = control->rng.outBuf;
-        control->rng.out_end = control->rng.out_cur + RNG_OUT_BUFFER_LEN;
-        
-        control->rng.inBuf = (char *) calloc(RNG_IN_BUFFER_LEN, sizeof(char));
-        if (control->rng.outBuf == NULL)
-            goto loser;
-    }
-
-    return CMTSuccess;
-
- loser:
-    if (control->rng.outBuf != NULL)
-    {
-        free(control->rng.outBuf);
-        control->rng.outBuf = NULL;
-    }
-    if (control->rng.inBuf != NULL)
-    {
-        free(control->rng.inBuf);
-        control->rng.inBuf = NULL;
-    }
-
-    return CMTFailure;
-}
-
-
-size_t 
-CMT_RequestPSMRandomData(PCMT_CONTROL control, 
-                         void *buf, CMUint32 maxbytes)
-{
-    SingleNumMessage req;
-    SingleItemMessage reply;
-    CMTItem message;
-    size_t rv = 0;
-    
-    /* Parameter checking */
-    if (!control || !buf || (maxbytes == 0))
-        goto loser;
-
-    /* Initialization. */
-    memset(&reply, 0, sizeof(SingleItemMessage));
-
-    /* Ask PSM for the data. */
-    req.value = maxbytes;
-    if (CMT_EncodeMessage(SingleNumMessageTemplate, &message, &req) != CMTSuccess)
-        goto loser;
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_MISC_ACTION | SSM_MISC_GET_RNG_DATA;
-    
-    /* Send the message and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure)
-        goto loser;
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_MISC_ACTION | SSM_MISC_GET_RNG_DATA))
-        goto loser;
-
-    /* Decode message */
-    if (CMT_DecodeMessage(SingleItemMessageTemplate, &reply, &message) != CMTSuccess)
-        goto loser;
-
-    /* Success - fill the return buf with what we got */
-    if (reply.item.len > maxbytes)
-        reply.item.len = maxbytes;
-
-    memcpy(buf, reply.item.data, reply.item.len);
-    rv = reply.item.len;
-
- loser:
-    if (reply.item.data)
-        free(reply.item.data);
-    if (message.data)
-        free(message.data);
-
-    return rv;
-}
-
-size_t 
-CMT_GenerateRandomBytes(PCMT_CONTROL control, 
-                        void *buf, CMUint32 maxbytes)
-{
-    CMUint32 remaining = maxbytes;
-    CMT_RNGState *rng = &(control->rng);
-    char *walk = (char *) buf;
-
-    /* Is there already enough in the incoming cache? */
-    while(remaining > rng->validInBytes)
-    {
-        /* Get what we have on hand. */
-        memcpy(walk, rng->in_cur, rng->validInBytes);
-        walk += rng->validInBytes;
-        remaining -= rng->validInBytes;
-
-        /* Request a buffer from PSM. */
-        rng->validInBytes = CMT_RequestPSMRandomData(control, 
-                                                     rng->inBuf, 
-                                                     RNG_IN_BUFFER_LEN);
-        if (rng->validInBytes == 0)
-            return (maxbytes - remaining); /* call failed */
-        rng->in_cur = rng->inBuf;
-    }
-    if (remaining > 0)
-    {
-        memcpy(walk, rng->in_cur, remaining);
-        rng->in_cur += remaining;
-        rng->validInBytes -= remaining;
-    }
-    return maxbytes;
-}
-
-void
-cmt_rng_xor(void *dstBuf, void *srcBuf, int len)
-{
-    unsigned char *s = (unsigned char*) srcBuf;
-    unsigned char *d = (unsigned char*) dstBuf;
-    unsigned char tmp;
-    int i;
-
-    for(i=0; i<len; i++, s++, d++)
-    {
-        tmp = *d;
-        /* I wish C had circular shift operators. So do others on the team. */
-        tmp = ((tmp << 1) | (tmp >> 7));
-        *d = tmp ^ *s;
-    }
-}
-
-CMTStatus 
-CMT_RandomUpdate(PCMT_CONTROL control, void *data, size_t numbytes)
-{
-    size_t dataLeft = numbytes, cacheLeft;
-    char *walk = (char *) data;
-
-    if (CMT_EnsureInitializedRNGBuf(control) != CMTSuccess)
-        goto loser;
-
-    /* If we have more than what the buffer can handle, wrap around. */
-    cacheLeft = (control->rng.out_end - control->rng.out_cur);
-    while (dataLeft >= cacheLeft)
-    {
-        cmt_rng_xor(control->rng.out_cur, walk, cacheLeft);
-        walk += cacheLeft;
-        dataLeft -= cacheLeft;
-
-        control->rng.out_cur = control->rng.outBuf;
-
-        /* Max out used space */
-        control->rng.validOutBytes = cacheLeft = RNG_OUT_BUFFER_LEN;
-    }
-
-    /* 
-       We now have less seed data available than we do space in the buf.
-       Write what we have and update validOutBytes if we're not looping already.
-     */
-    cmt_rng_xor(control->rng.out_cur, walk, dataLeft);
-    control->rng.out_cur += dataLeft;
-    if (control->rng.validOutBytes < RNG_OUT_BUFFER_LEN)
-        control->rng.validOutBytes += dataLeft;
-
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-size_t
-CMT_GetNoise(PCMT_CONTROL control, void *buf, CMUint32 maxbytes)
-{
-    /* ### mwelch - GetNoise and GenerateRandomBytes can be the 
-       same function now, because presumably the RNG is being 
-       seeded with environmental noise on the PSM end before we 
-       make any of these requests */
-    return CMT_GenerateRandomBytes(control, buf, maxbytes);
-}
-
-CMTStatus 
-CMT_FlushPendingRandomData(PCMT_CONTROL control)
-{
-    CMTItem message;
-
-    memset(&message, 0, sizeof(CMTItem));
-
-    if (CMT_EnsureInitializedRNGBuf(control) != CMTSuccess)
-        return CMTFailure; /* couldn't initialize RNG buffer */
-
-    if (control->rng.validOutBytes == 0)
-        return CMTSuccess; /* no random data available == we're flushed */
-
-    /* We have random data available. Send this to PSM.
-       We're sending an event, so no reply is needed. */
-    message.type = SSM_EVENT_MESSAGE 
-        | SSM_MISC_ACTION 
-        | SSM_MISC_PUT_RNG_DATA;
-    message.len = control->rng.validOutBytes;
-    message.data = (unsigned char *) calloc(message.len, sizeof(char));
-    if (!message.data)
-        goto loser;
-    memcpy(message.data, control->rng.outBuf, message.len);
-
-    if (CMT_TransmitMessage(control, &message) == CMTFailure)
-        goto loser;
-
-    /* Clear the RNG ring buffer, we've used that data */
-    control->rng.out_cur = control->rng.outBuf;
-    control->rng.validOutBytes = 0;
-    /* zero the buffer, because we XOR in new data */
-    memset(control->rng.outBuf, 0, RNG_OUT_BUFFER_LEN);
-
-    goto done;
- loser:
-    if (message.data)
-        free(message.data);
-    return CMTFailure;
- done:
-    return CMTSuccess;
-}

mozilla/security/psm/lib/client/cmtsdr.c

@@ -1,237 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-/*
-  cmtsdr.c -- Support for the Secret Decoder Ring, which provides
-      encryption and decryption using stored keys.
-
-  Created by thayes 18 April 2000
- */
-#include "stddef.h"
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "messages.h"
-#include "protocolshr.h"
-#include "rsrcids.h"
-#include <string.h>
-
-#undef PROCESS_LOCALLY
-
-/* Encryption result - contains the key id and the resulting data */
-/* An empty key id indicates that NO encryption was performed */
-typedef struct EncryptionResult
-{
-  CMTItem keyid;
-  CMTItem data;
-} EncryptionResult;
-
-/* Constants for testing */
-static const char *kPrefix = "Encrypted:";
-
-static CMTItem
-CMT_CopyDataToItem(const unsigned char *data, CMUint32 len)
-{
-  CMTItem item;
-
-  item.data = (unsigned char*) calloc(len, 1);
-  item.len = len;
-  memcpy(item.data, data, len);
-
-  return item;
-}
-
-
-static CMTStatus
-tmp_SendMessage(PCMT_CONTROL control, CMTItem *message)
-{
-#ifndef PROCESS_LOCALLY
-  return CMT_SendMessage(control, message);
-#else
-  if (message->type == SSM_SDR_ENCRYPT_REQUEST) 
-    return CMT_DoEncryptionRequest(message);
-  else if (message->type == SSM_SDR_DECRYPT_REQUEST)
-    return CMT_DoDecryptionRequest(message);
-
-  return CMTFailure;
-#endif
-}
-/* End test code */
-
-CMTStatus
-CMT_SDREncrypt(PCMT_CONTROL control, void *ctx,
-               const unsigned char *key, CMUint32 keyLen,
-               const unsigned char *data, CMUint32 dataLen,
-               unsigned char **result, CMUint32 *resultLen)
-{
-  CMTStatus rv = CMTSuccess;
-  CMTItem message;
-  EncryptRequestMessage request;
-  SingleItemMessage reply;
-
-  /* Fill in the request */
-  request.keyid = CMT_CopyDataToItem(key, keyLen);
-  request.data = CMT_CopyDataToItem(data, dataLen);
-  request.ctx = CMT_CopyPtrToItem(ctx);
-
-  reply.item.data = 0;
-  reply.item.len = 0;
-  message.data = 0;
-  message.len = 0;
-
-  /* Encode */
-  rv = CMT_EncodeMessage(EncryptRequestTemplate, &message, &request);
-  if (rv != CMTSuccess) {
-    goto loser;
-  }
-
-  message.type = SSM_SDR_ENCRYPT_REQUEST;
-
-  /* Send */
-  /* if (CMT_SendMessage(control, &message) != CMTSuccess) goto loser; */
-  rv = tmp_SendMessage(control, &message);
-  if (rv != CMTSuccess) goto loser;
-
-  if (message.type != SSM_SDR_ENCRYPT_REPLY) { rv = CMTFailure; goto loser; }
-
-  rv = CMT_DecodeMessage(SingleItemMessageTemplate, &reply, &message);
-  if (rv != CMTSuccess)
-    goto loser;
-
-  *result = reply.item.data;
-  *resultLen = reply.item.len;
-
-  reply.item.data = 0;
-
-loser:
-  if (message.data) free(message.data);
-  if (request.keyid.data) free(request.keyid.data);
-  if (request.data.data) free(request.data.data);
-  if (request.ctx.data) free(request.ctx.data);
-  if (reply.item.data) free(reply.item.data);
-
-  return rv; /* need return value */
-}
-
-CMTStatus
-CMT_SDRDecrypt(PCMT_CONTROL control, void *ctx,
-               const unsigned char *data, CMUint32 dataLen,
-               unsigned char **result, CMUint32 *resultLen)
-{
-  CMTStatus rv;
-  CMTItem message;
-  DecryptRequestMessage request;
-  SingleItemMessage reply;
-
-  /* Fill in the request */
-  request.data = CMT_CopyDataToItem(data, dataLen);
-  request.ctx = CMT_CopyPtrToItem(ctx);
-
-  reply.item.data = 0;
-  reply.item.len = 0;
-  message.data = 0;
-  message.len = 0;
-
-  /* Encode */
-  rv = CMT_EncodeMessage(DecryptRequestTemplate, &message, &request);
-  if (rv != CMTSuccess) {
-    goto loser;
-  }
-
-  message.type = SSM_SDR_DECRYPT_REQUEST;
-
-  /* Send */
-  /* if (CMT_SendMessage(control, &message) != CMTSuccess) goto loser; */
-  rv = tmp_SendMessage(control, &message);
-  if (rv != CMTSuccess) goto loser;
-
-  if (message.type != SSM_SDR_DECRYPT_REPLY) { rv = CMTFailure; goto loser; }
-
-  rv = CMT_DecodeMessage(SingleItemMessageTemplate, &reply, &message);
-  if (rv != CMTSuccess)
-    goto loser;
-
-  *result = reply.item.data;
-  *resultLen = reply.item.len;
-
-  reply.item.data = 0;
-
-loser:
-  if (message.data) free(message.data);
-  if (request.data.data) free(request.data.data);
-  if (request.ctx.data) free(request.ctx.data);
-  if (reply.item.data) free(reply.item.data);
-
-  return rv; /* need return value */
-}
-
-CMTStatus
-CMT_SDRChangePassword(PCMT_CONTROL control, void *ctx)
-{
-  CMTStatus rv = CMTSuccess;
-  CMTItem message;
-  SingleItemMessage request;
-  SingleNumMessage reply;
-
-  /* Fill in the request */
-  request.item = CMT_CopyPtrToItem(ctx);
-
-  message.data = 0;
-  message.len = 0;
-
-  /* Encode */
-  rv = CMT_EncodeMessage(SingleItemMessageTemplate, &message, &request);
-  if (rv != CMTSuccess) {
-    goto loser;
-  }
-
-  message.type = (SSM_REQUEST_MESSAGE|SSM_MISC_ACTION|SSM_MISC_UI|SSM_UI_CHANGE_PASSWORD);
-
-  /* Send */
-  rv = CMT_SendMessage(control, &message);
-  if (rv != CMTSuccess) goto loser;
-
-  if (message.type != 
-     (SSM_REPLY_OK_MESSAGE|SSM_MISC_ACTION|SSM_MISC_UI|SSM_UI_CHANGE_PASSWORD)) { 
-    rv = CMTFailure;
-    goto loser; 
-  }
-
-  rv = CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message);
-  if (rv != CMTSuccess)
-    goto loser;
-
-loser:
-  if (request.item.data) free(request.item.data);
-  if (message.data) free(message.data);
-
-  return rv; /* need return value */
-}

mozilla/security/psm/lib/client/cmtssl.c

@@ -1,467 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifdef XP_UNIX
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#else
-#ifdef XP_MAC
-#else /* windows */
-#include <windows.h>
-#include <winsock.h>
-#endif
-#endif
-#include <errno.h>
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "messages.h"
-#include "rsrcids.h"
-
-
-
-CMTStatus CMT_OpenSSLConnection(PCMT_CONTROL control, CMTSocket sock,
-                                SSMSSLConnectionRequestType flags, 
-                                CMUint32 port, char * hostIP, 
-                                char * hostName, CMBool forceHandshake, void* clientContext)
-{
-	CMTItem message;
-    SSLDataConnectionRequest request;
-    DataConnectionReply reply;
-    CMUint32 sent;
-	
-	/* Do some parameter checking */
-	if (!control || !hostIP || !hostName) {
-		goto loser;
-	}
-
-    request.flags = flags;
-    request.port = port;
-    request.hostIP = hostIP;
-    request.hostName = hostName;
-    request.forceHandshake = forceHandshake;
-    request.clientContext = CMT_CopyPtrToItem(clientContext);
-
-    /* Encode message */
-    if (CMT_EncodeMessage(SSLDataConnectionRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_DATA_CONNECTION | SSM_SSL_CONNECTION;
-    
-	/* Send the message and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_DATA_CONNECTION | SSM_SSL_CONNECTION)) {
-        goto loser;
-    }
-
-    /* Decode message */
-    if (CMT_DecodeMessage(DataConnectionReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-	/* Success */
-	if (reply.result == 0) {
-	  if (control->sockFuncs.connect(sock, reply.port, NULL) != CMTSuccess) {
-            goto loser;
-	  }
-	  sent = CMT_WriteThisMany(control, sock, control->nonce.data, 
-                               control->nonce.len);
-	  if (sent != control->nonce.len) {
-            goto loser;
-	  }
-	  
-	  /* Save connection info */
-	  if (CMT_AddDataConnection(control, sock, reply.connID)
-	      != CMTSuccess) {
-	    goto loser;
-	  }
-
-	  return CMTSuccess;
-	} 
-	
-loser:
-	return CMTFailure;
-}
-
-CMTStatus CMT_GetSSLDataErrorCode(PCMT_CONTROL control, CMTSocket sock,
-                                  CMInt32* errorCode)
-{
-    CMUint32 connID;
-
-    if (!control || !errorCode) {
-        goto loser;
-    }
-
-    /* get the data connection */
-    if (CMT_GetDataConnectionID(control, sock, &connID) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* get the PR error */
-    if (CMT_GetNumericAttribute(control, connID, SSM_FID_SSLDATA_ERROR_VALUE,
-                                errorCode) != CMTSuccess) {
-        goto loser;
-    }
-
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_ReleaseSSLSocketStatus(PCMT_CONTROL control, CMTSocket sock)
-{
-    CMUint32 connectionID;
-
-    if (!control || !sock) {
-        goto loser;
-    }
-    if (CMT_GetDataConnectionID(control, sock, &connectionID) != CMTSuccess) {
-        goto loser;
-    }
-    if (CMT_SetNumericAttribute(control, connectionID, 
-                                SSM_FID_SSLDATA_DISCARD_SOCKET_STATUS,
-                                0) != CMTSuccess) {
-        goto loser;
-    }
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_GetSSLSocketStatus(PCMT_CONTROL control, CMTSocket sock, 
-                                 CMTItem* pickledStatus, CMInt32* level)
-{
-    CMUint32 connectionID;
-    SingleNumMessage request;
-    CMTItem message;
-    PickleSecurityStatusReply reply;
-
-    if (!control || !pickledStatus || !level) {
-        goto loser;
-    }
-
-	/* get the data connection */
-    if (CMT_GetDataConnectionID(control, sock, &connectionID) != CMTSuccess) {
-		goto loser;
-	}
-
-    /* set up the request */
-    request.value = connectionID;
-
-    /* encode the request */
-    if (CMT_EncodeMessage(SingleNumMessageTemplate, &message, &request) !=
-        CMTSuccess) {
-        goto loser;
-    }
-
-    /* set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | 
-        SSM_CONSERVE_RESOURCE | SSM_PICKLE_SECURITY_STATUS;
-
-    /* send the message and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION |
-                         SSM_CONSERVE_RESOURCE | SSM_PICKLE_SECURITY_STATUS)) {
-        goto loser;
-    }
-
-    /* decode the reply */
-    if (CMT_DecodeMessage(PickleSecurityStatusReplyTemplate, &reply, &message)
-        != CMTSuccess) {
-        goto loser;
-    }
-
-    /* success */
-    if (reply.result == 0) {
-        *pickledStatus = reply.blob;
-        *level = reply.securityLevel;
-        return CMTSuccess;
-    }
-
-loser:
-    return CMTFailure;
-}
-
-
-CMTStatus CMT_OpenTLSConnection(PCMT_CONTROL control, CMTSocket sock,
-                                CMUint32 port, char* hostIP, char* hostName)
-{
-    TLSDataConnectionRequest request;
-    CMTItem message;
-    DataConnectionReply reply;
-    CMUint32 sent;
-
-    /* do some parameter checking */
-    if (!control || !hostIP || !hostName) {
-        goto loser;
-    }
-
-    request.port = port;
-    request.hostIP = hostIP;
-    request.hostName = hostName;
-
-    /* encode the message */
-    if (CMT_EncodeMessage(TLSDataConnectionRequestTemplate, &message, &request)
-        != CMTSuccess) {
-        goto loser;
-    }
-
-    /* set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_DATA_CONNECTION | 
-        SSM_TLS_CONNECTION;
-
-    /* send the message and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_DATA_CONNECTION | 
-                         SSM_TLS_CONNECTION)) {
-        goto loser;
-    }
-
-    /* decode the message */
-    if (CMT_DecodeMessage(DataConnectionReplyTemplate, &reply, &message) !=
-        CMTSuccess) {
-        goto loser;
-    }
-
-    /* success */
-    if (reply.result == 0) {
-        if (control->sockFuncs.connect(sock, reply.port, NULL) != CMTSuccess) {
-            goto loser;
-        }
-        sent = CMT_WriteThisMany(control, sock, control->nonce.data, 
-                                 control->nonce.len);
-        if (sent != control->nonce.len) {
-            goto loser;
-        }
-
-        /* save connection info */
-        if (CMT_AddDataConnection(control, sock, reply.connID) != CMTSuccess) {
-            goto loser;
-        }
-
-        return CMTSuccess;
-    }
-loser:
-    return CMTFailure;
-}
-
-
-CMTStatus CMT_TLSStepUp(PCMT_CONTROL control, CMTSocket sock, 
-                        void* clientContext)
-{
-    TLSStepUpRequest request;
-    SingleNumMessage reply;
-    CMTItem message;
-    CMUint32 connectionID;
-
-    /* check arguments */
-    if (!control || !sock) {
-        goto loser;
-    }
-
-    /* get the data connection ID */
-    if (CMT_GetDataConnectionID(control, sock, &connectionID) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* set up the request */
-    request.connID = connectionID;
-    request.clientContext = CMT_CopyPtrToItem(clientContext);
-
-    /* encode the request */
-    if (CMT_EncodeMessage(TLSStepUpRequestTemplate, &message, &request) !=
-        CMTSuccess) {
-        goto loser;
-    }
-
-    /* set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | SSM_TLS_STEPUP;
-
-    /* send the message and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION |
-                         SSM_TLS_STEPUP)) {
-        goto loser;
-    }
-
-    /* decode the reply */
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) !=
-        CMTSuccess) {
-        goto loser;
-    }
-
-    return (CMTStatus) reply.value;
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_OpenSSLProxyConnection(PCMT_CONTROL control, CMTSocket sock,
-                                     CMUint32 port, char* hostIP, 
-                                     char* hostName)
-{
-    TLSDataConnectionRequest request;
-    CMTItem message;
-    DataConnectionReply reply;
-    CMUint32 sent;
-
-    /* do some parameter checking */
-    if (!control || !hostIP || !hostName) {
-        goto loser;
-    }
-
-    request.port = port;
-    request.hostIP = hostIP;
-    request.hostName = hostName;
-
-    /* encode the message */
-    if (CMT_EncodeMessage(TLSDataConnectionRequestTemplate, &message, &request)
-        != CMTSuccess) {
-        goto loser;
-    }
-
-    /* set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_DATA_CONNECTION | 
-        SSM_PROXY_CONNECTION;
-
-    /* send the message and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_DATA_CONNECTION | 
-                         SSM_PROXY_CONNECTION)) {
-        goto loser;
-    }
-
-    /* decode the message */
-    if (CMT_DecodeMessage(DataConnectionReplyTemplate, &reply, &message) !=
-        CMTSuccess) {
-        goto loser;
-    }
-
-    /* success */
-    if (reply.result == 0) {
-        if (control->sockFuncs.connect(sock, reply.port, NULL) != CMTSuccess) {
-            goto loser;
-        }
-        sent = CMT_WriteThisMany(control, sock, control->nonce.data, 
-                                 control->nonce.len);
-        if (sent != control->nonce.len) {
-            goto loser;
-        }
-
-        /* save connection info */
-        if (CMT_AddDataConnection(control, sock, reply.connID) != CMTSuccess) {
-            goto loser;
-        }
-
-        return CMTSuccess;
-    }
-loser:
-    return CMTFailure;
-}
-
-
-CMTStatus CMT_ProxyStepUp(PCMT_CONTROL control, CMTSocket sock, 
-                        void* clientContext, char* remoteUrl)
-{
-    ProxyStepUpRequest request;
-    SingleNumMessage reply;
-    CMTItem message;
-    CMUint32 connectionID;
-
-    /* check arguments */
-    if (!control || !sock || !remoteUrl) {
-        goto loser;
-    }
-
-    /* get the data connection ID */
-    if (CMT_GetDataConnectionID(control, sock, &connectionID) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* set up the request */
-    request.connID = connectionID;
-    request.clientContext = CMT_CopyPtrToItem(clientContext);
-    request.url = remoteUrl;
-
-    /* encode the request */
-    if (CMT_EncodeMessage(ProxyStepUpRequestTemplate, &message, &request) !=
-        CMTSuccess) {
-        goto loser;
-    }
-
-    /* set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | 
-        SSM_PROXY_STEPUP;
-
-    /* send the message and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION |
-                         SSM_PROXY_STEPUP)) {
-        goto loser;
-    }
-
-    /* decode the reply */
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) !=
-        CMTSuccess) {
-        goto loser;
-    }
-
-    return (CMTStatus) reply.value;
-loser:
-    return CMTFailure;
-}

mozilla/security/psm/lib/client/cmtutils.c

@@ -1,636 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifdef XP_UNIX
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#else
-#ifdef XP_MAC
-#include "macsocket.h"
-#else /* Windows */
-#include <windows.h>
-#include <winsock.h>
-#endif
-#endif
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "newproto.h"
-#include <string.h>
-
-/* Local defines */
-#if 0
-#define PSM_WAIT_BEFORE_SLEEP           (CM_TicksPerSecond() * 60)
-#define PSM_SPINTIME                    PSM_WAIT_BEFORE_SLEEP
-#define PSM_KEEP_CONNECTION_ALIVE       (PSM_WAIT_BEFORE_SLEEP * 900)
-#endif
-
-/* If you want to dump the messages sent between the plug-in and the PSM 
- * server, then remove the comment for the appropriate define.
- */
-#if 0
-#define PRINT_SEND_MESSAGES
-#define PRINT_RECEIVE_MESSAGES
-#endif
-
-#ifdef PRINT_SEND_MESSAGES
-#ifndef DEBUG_MESSAGES
-#define DEBUG_MESSAGES
-#endif /*DEBUG_MESSAGES*/
-#endif /*PRINT_SEND_MESSAGES*/
-
-#ifdef PRINT_RECEIVE_MESSAGES
-#ifndef DEBUG_MESSAGES
-#define DEBUG_MESSAGES
-#endif /*DEBUG_MESSAGES*/
-#endif /*PRINT_RECEIVE_MESSAGES*/
-
-#ifdef DEBUG_MESSAGES
-#define LOG(x) do { FILE *f; f=fopen("cmnav.log","a+"); if (f) { \
-   fprintf(f, x); fclose(f); } } while(0);
-#define LOG_S(x) do { FILE *f; f=fopen("cmnav.log","a+"); if (f) { \
-   fprintf(f, "%s", x); fclose(f); } } while(0);
-#define ASSERT(x) if (!(x)) { LOG("ASSERT:"); LOG(#x); LOG("\n"); exit(-1); }
-#else
-#define LOG(x)
-#define LOG_S(x)
-#define ASSERT(x)
-#endif
-
-CMUint32
-cmt_Strlen(char *str)
-{
-    CMUint32 len = strlen(str);
-    return sizeof(CMInt32) + (((len + 3)/4)*4);
-}
-
-CMUint32
-cmt_Bloblen(CMTItem *blob)
-{
-    return sizeof(CMInt32) + (((blob->len +3)/4)*4);
-}
-
-char *
-cmt_PackString(char *buf, char *str)
-{
-    CMUint32 len = strlen(str);
-    CMUint32 networkLen = htonl(len);
-    CMUint32 padlen = ((len + 3)/4)*4;
-
-    memcpy(buf, &networkLen, sizeof(CMUint32));
-    memcpy(buf + sizeof(CMUint32), str, len);
-    memset(buf + sizeof(CMUint32) + len, 0, padlen - len);
-
-    return buf+sizeof(CMUint32)+padlen;
-}
-
-char *
-cmt_PackBlob(char *buf, CMTItem *blob)
-{
-    CMUint32 len = blob->len;
-    CMUint32 networkLen = htonl(len);
-    CMUint32 padlen = (((blob->len + 3)/4)*4);
-
-    *((CMUint32*)buf) = networkLen;
-    memcpy(buf + sizeof(CMUint32), blob->data, len);
-    memset(buf + sizeof(CMUint32) + len, 0, padlen - len);
-
-    return buf + sizeof(CMUint32) + padlen;
-}
-
-char *
-cmt_UnpackString(char *buf, char **str)
-{
-    char *p = NULL;
-    CMUint32 len, padlen;
-
-    /* Get the string length */
-    len = ntohl(*(CMUint32*)buf);
-
-    /* Get the padded length */
-    padlen = ((len + 3)/4)*4;
-
-    /* Allocate the string and copy the data */
-    p = (char *) malloc(len + 1);
-    if (!p) {
-        goto loser;
-    }
-    /* Copy the data and NULL terminate */
-    memcpy(p, buf+sizeof(CMUint32), len);
-    p[len] = 0;
-
-    *str = p;
-    return buf+sizeof(CMUint32)+padlen;
-loser:
-    *str = NULL;
-    if (p) {
-        free(p);
-    }
-    return buf+sizeof(CMUint32)+padlen;
-}
-
-char *
-cmt_UnpackBlob(char *buf, CMTItem **blob)
-{
-    CMTItem *p = NULL;
-    CMUint32 len, padlen;
-
-    /* Get the blob length */
-    len = ntohl(*(CMUint32*)buf);
-    
-    /* Get the padded length */
-    padlen = ((len + 3)/4)*4;
-
-    /* Allocate the CMTItem for the blob */
-    p = (CMTItem*)malloc(sizeof(CMTItem));
-    if (!p) {
-        goto loser;
-    }
-    p->len = len;
-    p->data = (unsigned char *) malloc(len);
-    if (!p->data) {
-        goto loser;
-    }
-
-    /* Copy that data across */
-    memcpy(p->data, buf+sizeof(CMUint32), len);
-    *blob = p;
-
-    return buf+sizeof(CMUint32)+padlen;
-
-loser:
-    *blob = NULL;
-    CMT_FreeMessage(p);
-
-    return buf+sizeof(CMUint32)+padlen;
-}
-
-#ifdef DEBUG_MESSAGES
-void prettyPrintMessage(CMTItem *msg)
-{
-  int numLines = ((msg->len+7)/8);
-  char curBuffer[9], *cursor, string[2], hexVal[8];
-  char hexArray[25];
-  int i, j, numToCopy;
-
-  /*Try printing out 8 bytes at a time. */
-  LOG("\n**********************************************************\n");
-  LOG("About to pretty Print Message\n\n");
-  curBuffer[9] = '\0';
-  hexArray[24] = '\0';
-  hexVal[2] = '\0';
-  string[1] = '\0';
-  LOG("Header Info\n");
-  LOG("Message Type: ");
-  sprintf(hexArray, "%lx\n", msg->type);
-  LOG(hexArray);
-  LOG("Message Length: ");
-  sprintf (hexArray, "%ld\n\n", msg->len);
-  LOG(hexArray);
-  LOG("Body of Message\n");
-  for (i=0, cursor=msg->data; i<numLines; i++, cursor+=8) {
-    /* First copy over the buffer to our local array */
-    numToCopy = ((msg->len - (unsigned int)((unsigned long)cursor-(unsigned long)msg->data)) < 8) ?
-                msg->len - (unsigned int)((unsigned long)cursor-(unsigned long)msg->data) : 8;
-    memcpy(curBuffer, cursor, 8);
-    for (j=0;j<numToCopy;j++) {
-      string[0] = curBuffer[j];
-      if (isprint(curBuffer[j])) {
-	string[0] = curBuffer[j];
-      } else {
-	string[0] = ' ';
-      }
-      LOG(string);
-    }
-    string[0] = ' ';
-    for (;j<8;j++) {
-      LOG(string);
-    }
-    LOG("\t");
-    for (j=0; j<numToCopy; j++) {
-      sprintf (hexVal,"%.2x", 0x0ff & (unsigned short)curBuffer[j]);
-      LOG(hexVal);
-      LOG(" ");
-    }
-    LOG("\n");
-  }
-  LOG("Done Pretty Printing Message\n");
-  LOG("**********************************************************\n\n");
-}
-#endif
-
-CMTStatus CMT_SendMessage(PCMT_CONTROL control, CMTItem* message)
-{
-	CMTStatus status;
-    CMUint32 msgCategory;
-    CMBool done = CM_FALSE;
-#ifdef PRINT_SEND_MESSAGES
-    LOG("About to print message sent to PSM\n");
-    prettyPrintMessage(message);
-#endif
-
-    /* Acquire lock on the control connection */
-    CMT_LOCK(control->mutex);
-
-    /* Try to send pending random data */
-    if (message->type != (SSM_REQUEST_MESSAGE | SSM_HELLO_MESSAGE))
-    {
-        /* If we've already said hello, then flush random data
-           just before sending the request. */
-        status = CMT_FlushPendingRandomData(control);
-        if (status != CMTSuccess)
-            goto loser;
-    }
-    
-	status = CMT_TransmitMessage(control, message);
-	if (status != CMTSuccess) {
-		goto loser;
-	}
-
-    /* We have to deal with other types of data on the socket and */
-    /* handle them accordingly */
-    while (!done) {
-    	status = CMT_ReceiveMessage(control, message);
-        if (status != CMTSuccess) {
-            goto loser;
-        }
-        msgCategory = (message->type & SSM_CATEGORY_MASK);
-        switch (msgCategory) {
-            case SSM_REPLY_OK_MESSAGE:
-                done = CM_TRUE;
-                break;
-            case SSM_REPLY_ERR_MESSAGE:
-                done = CM_TRUE;
-                break;
-            case SSM_EVENT_MESSAGE:
-                CMT_DispatchEvent(control, message);
-                break;
-            /* XXX FIX THIS!!! For the moment I'm ignoring all other types */
-            default:
-                break;
-        }
-    }
-
-    /* Release the control connection lock */
-    CMT_UNLOCK(control->mutex);
-	return CMTSuccess;
-loser:
-    /* Release the control connection lock */
-    CMT_UNLOCK(control->mutex);
-	return CMTFailure;
-}
-
-CMTStatus CMT_TransmitMessage(PCMT_CONTROL control, CMTItem * message)
-{
-    CMTMessageHeader header;
-	CMUint32 sent, rv;
-
-    /* Set up the message header */
-    header.type = htonl(message->type);
-    header.len = htonl(message->len);
-
-	/* Send the message header */
-	sent = CMT_WriteThisMany(control, control->sock, 
-                             (void *)&header, sizeof(CMTMessageHeader));
-	if (sent != sizeof(CMTMessageHeader)) {
-		goto loser;
-	}
-
-	/* Send the message body */
-	sent = CMT_WriteThisMany(control, control->sock, (void *)message->data, 
-                             message->len);
-	if (sent != message->len) {
-		goto loser;
-	}
-
-    /* Free the buffer */
-    free(message->data);
-    message->data = NULL;
-	return CMTSuccess;
-
-loser:
-	return CMTFailure;
-}
-
-CMTStatus CMT_ReceiveMessage(PCMT_CONTROL control, CMTItem * response)
-{
-    CMTMessageHeader header;
-    CMUint32 numread, rv;
-
-    /* Get the message header */
-    numread = CMT_ReadThisMany(control, control->sock, 
-                            (void *)&header, sizeof(CMTMessageHeader));
-    if (numread != sizeof(CMTMessageHeader)) {
-        goto loser;
-    }
-
-    response->type = ntohl(header.type);
-    response->len = ntohl(header.len);
-    response->data = (unsigned char *) malloc(response->len);
-    if (response->data == NULL) {
-        goto loser;
-    }
-
-    numread = CMT_ReadThisMany(control, control->sock, 
-                            (void *)(response->data), response->len); 
-    if (numread != response->len) {
-        goto loser;
-    }
-
-#ifdef PRINT_RECEIVE_MESSAGES
-    LOG("About to print message received from PSM.\n");
-    prettyPrintMessage(response);
-#endif /*PRINT_RECEIVE_MESSAGES*/
-    return CMTSuccess;
-loser:
-    if (response->data) {
-        free(response->data);
-    }
-    return CMTFailure;
-}
-
-CMUint32 CMT_ReadThisMany(PCMT_CONTROL control, CMTSocket sock, 
-                          void * buffer, CMUint32 thisMany)
-{
-	CMUint32 total = 0;
-  
-	while (total < thisMany) {
-		int got;
-		got = control->sockFuncs.recv(sock, (void*)((char*)buffer + total),
-                                      thisMany-total);
-		if (got < 0 ) {
-			break;
-		} 
-		total += got;
-	} 
-	return total;
-}
- 
-CMUint32 CMT_WriteThisMany(PCMT_CONTROL control, CMTSocket sock, 
-                           void * buffer, CMUint32 thisMany)
-{
-	CMUint32 total = 0;
-  
-	while (total < thisMany) {
-		CMInt32 got;
-		got = control->sockFuncs.send(sock, (void*)((char*)buffer+total), 
-                                      thisMany-total);
-		if (got < 0) {
-			break;
-		}
-		total += got;
-	}
-	return total;
-}
-
-CMTItem* CMT_ConstructMessage(CMUint32 type, CMUint32 length)
-{
-    CMTItem * p;
-
-    p = (CMTItem*)malloc(sizeof(CMTItem));
-    if (!p) {
-	goto loser;
-    }
-
-    p->type = type;
-    p->len = length;
-    p->data = (unsigned char *) malloc(length);
-    if (!p->data) {
-	goto loser;
-    }
-    return p;
-
-loser:
-    CMT_FreeMessage(p);
-    return NULL;
-}
-
-void CMT_FreeMessage(CMTItem * p)
-{
-    if (p != NULL) {
-	if (p->data != NULL) {
-	    free(p->data);
-	}
-	free(p);
-    }
-}
-
-CMTStatus CMT_AddDataConnection(PCMT_CONTROL control, CMTSocket sock, 
-                                CMUint32 connectionID)
-{
-	PCMT_DATA ptr;
-
-	/* This is the first connection */
-	if (control->cmtDataConnections == NULL) {
-		control->cmtDataConnections = ptr = 
-            (PCMT_DATA)calloc(sizeof(CMT_DATA), 1);
-		if (!ptr) {
-			goto loser;
-		}
-	} else {
-	    /* Position at the last entry */
-	    for (ptr = control->cmtDataConnections; (ptr != NULL && ptr->next 
-                                                 != NULL); ptr = ptr->next);
-		ptr->next = (PCMT_DATA)calloc(sizeof(CMT_DATA), 1);
-		if (!ptr->next) {
-			goto loser;
-		} 
-		/* Fix up the pointers */
-		ptr->next->previous = ptr;
-		ptr = ptr->next;
-	}
-
-	/* Fill in the data */
-	ptr->sock = sock;
-	ptr->connectionID = connectionID;
-
-	return CMTSuccess;
-loser:
-	return CMTFailure;
-}
-
-int
-CMT_DestroyDataConnection(PCMT_CONTROL control, CMTSocket sock)
-{
-    PCMT_DATA ptr, pptr = NULL;
-    int rv=CMTSuccess;
-
-    control->sockFuncs.close(sock);
-    for (ptr = control->cmtDataConnections; ptr != NULL;
-	 pptr = ptr, ptr = ptr->next) {
-	if (ptr->sock == sock) {
-	    if (pptr == NULL) {
-		/* node is at head */
-		control->cmtDataConnections = ptr->next;
-		if (ptr->priv != NULL)
-		    ptr->priv->dest(ptr->priv);
-		free(ptr);
-		return rv;
-	    }
-	    /* node is elsewhere */
-	    pptr->next = ptr->next;
-	    if (ptr->priv != NULL)
-	        ptr->priv->dest(ptr->priv);
-	    free(ptr);
-	    return rv;
-	}
-    }
-    return rv;
-}
-
-CMTStatus CMT_CloseDataConnection(PCMT_CONTROL control, CMUint32 connectionID)
-{
-    /* PCMT_DATA ptr, pptr = NULL; */
-    CMTSocket sock;
-    /* int rv;*/
-
-    /* Get the socket for this connection */
-    if (CMT_GetDataSocket(control, connectionID, &sock) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Free data connection associated with this socket */
-    if (CMT_DestroyDataConnection(control, sock) == CMTFailure) {
-        goto loser;
-    }
-
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_GetDataConnectionID(PCMT_CONTROL control, CMTSocket sock, CMUint32 * connectionID)
-{
-	PCMT_DATA ptr;
-
-	for (ptr = control->cmtDataConnections; ptr != NULL; ptr = ptr->next) {
-		if (ptr->sock == sock) {
-			*connectionID = ptr->connectionID;
-			return CMTSuccess;
-		}
-	}
-
-	return CMTFailure;
-}
-
-CMTStatus CMT_GetDataSocket(PCMT_CONTROL control, CMUint32 connectionID, CMTSocket * sock)
-{
-	PCMT_DATA ptr;
-
-	for (ptr = control->cmtDataConnections; ptr != NULL; ptr = ptr->next) {
-		if (ptr->connectionID == connectionID) {
-			*sock = ptr->sock;
-			return CMTSuccess;
-		}
-	}
-
-	return CMTFailure;
-}
-
-
-CMTStatus CMT_SetPrivate(PCMT_CONTROL control, CMUint32 connectionID,
-			 CMTPrivate *cmtpriv)
-{
-  PCMT_DATA ptr;
-
-  for (ptr = control->cmtDataConnections; ptr != NULL; ptr = ptr->next) {
-    if (ptr->connectionID == connectionID) {
-      ptr->priv = cmtpriv;
-      return CMTSuccess;
-    }
-  }
-  return CMTFailure;
-}
-
-CMTPrivate *CMT_GetPrivate(PCMT_CONTROL control, CMUint32 connectionID)
-{
-  PCMT_DATA ptr;
-
-  for (ptr = control->cmtDataConnections; ptr != NULL; ptr = ptr->next) {
-    if (ptr->connectionID == connectionID) {
-      return ptr->priv;
-    }
-  }
-  return NULL;
-}
-
-void CMT_FreeItem(CMTItem *p)
-{
-  CMT_FreeMessage(p);
-}
-
-CMTItem CMT_CopyPtrToItem(void* p)
-{
-    CMTItem value = {0, NULL, 0};
-
-    if (!p) {
-        return value;
-    }
-
-    value.len = sizeof(p);
-    value.data = (unsigned char *) malloc(value.len);
-    memcpy(value.data, &p, value.len);
-
-    return value;
-}
-
-void * CMT_CopyItemToPtr(CMTItem value)
-{
-    void * p = NULL;
-
-    if (value.len == sizeof(void*)) {
-        memcpy(&p, value.data, value.len);
-    }
-
-    return p;
-}
-
-CMTStatus CMT_ReferenceControlConnection(PCMT_CONTROL control)
-{
-    CMT_LOCK(control->mutex);
-    control->refCount++;
-    CMT_UNLOCK(control->mutex);
-    return CMTSuccess;
-}
-
-void
-CMT_LockConnection(PCMT_CONTROL control)
-{
-    CMT_LOCK(control->mutex);
-}
-
-void
-CMT_UnlockConnection(PCMT_CONTROL control)
-{
-    CMT_UNLOCK(control->mutex);
-}

mozilla/security/psm/lib/client/cmtutils.h

@@ -1,75 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifndef __CMTUTILS_H__
-#define __CMTUTILS_H__
-
-#include "cmtcmn.h"
-
-#define New(type) (type*)malloc(sizeof(type))
-#define NewArray(type, size) (type*)malloc(sizeof(type)*(size))
-
-PCMT_EVENT CMT_GetEventHandler(PCMT_CONTROL control, CMUint32 type,
-                               CMUint32 resourceID);
-
-CMUint32 cmt_Strlen(char *str);
-char *cmt_PackString(char *buf, char *str);
-char *cmt_UnpackString(char *buf, char **str);
-
-CMUint32 cmt_Bloblen(CMTItem* len);
-char *cmt_PackBlob(char *buf, CMTItem * blob);
-char *cmt_UnpackBlob(char *buf, CMTItem **blob);
-
-CMTStatus CMT_SendMessage(PCMT_CONTROL control, CMTItem* message);
-CMTStatus CMT_TransmitMessage(PCMT_CONTROL control, CMTItem * message);
-CMTStatus CMT_ReceiveMessage(PCMT_CONTROL control, CMTItem * response);
-CMUint32 CMT_ReadThisMany(PCMT_CONTROL control, CMTSocket sock, 
-			  void * buffer, CMUint32 thisMany);
-CMUint32 CMT_WriteThisMany(PCMT_CONTROL control, CMTSocket sock, 
-			   void * buffer, CMUint32 thisMany);
-CMTItem* CMT_ConstructMessage(CMUint32 type, CMUint32 length);
-void CMT_FreeMessage(CMTItem * p);
-CMTStatus CMT_AddDataConnection(PCMT_CONTROL control, CMTSocket sock, CMUint32 connectionID);
-CMTStatus CMT_GetDataConnectionID(PCMT_CONTROL control, CMTSocket sock, CMUint32 * connectionID);
-CMTStatus CMT_GetDataSocket(PCMT_CONTROL control, CMUint32 connectionID, CMTSocket * sock);
-CMTStatus CMT_CloseDataConnection(PCMT_CONTROL control, CMUint32 connectionID);
-CMTStatus CMT_SetPrivate(PCMT_CONTROL control, CMUint32 connectionID,
-			 CMTPrivate *cmtpriv);
-CMTPrivate *CMT_GetPrivate(PCMT_CONTROL control, CMUint32 connectionID);
-void CMT_ServicePasswordRequest(PCMT_CONTROL cm_control, CMTItem * requestData);
-void CMT_ProcessEvent(PCMT_CONTROL cm_control);
-void CMT_DispatchEvent(PCMT_CONTROL cm_control, CMTItem * eventData);
-CMTItem CMT_CopyPtrToItem(void* p);
-void * CMT_CopyItemToPtr(CMTItem value);
-
-#endif /* __CMTUTILS_H__ */
-

mozilla/security/psm/lib/client/config.mk

@@ -1,44 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-# 
-
-#
-#  Override TARGETS variable so that only static libraries
-#  are specifed as dependencies within rules.mk.
-#
-
-TARGETS        = $(LIBRARY)
-SHARED_LIBRARY =
-IMPORT_LIBRARY =
-PURE_LIBRARY   =
-PROGRAM        =
-

mozilla/security/psm/lib/client/makefile.win

@@ -1,125 +0,0 @@
-#// 
-#// The contents of this file are subject to the Mozilla Public
-#// License Version 1.1 (the "License"); you may not use this file
-#// except in compliance with the License. You may obtain a copy of
-#// the License at http://www.mozilla.org/MPL/
-#// 
-#// Software distributed under the License is distributed on an "AS
-#// IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-#// implied. See the License for the specific language governing
-#// rights and limitations under the License.
-#// 
-#// The Original Code is the Netscape security libraries.
-#// 
-#// The Initial Developer of the Original Code is Netscape
-#// Communications Corporation.  Portions created by Netscape are 
-#// Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-#// Rights Reserved.
-#// 
-#// Contributor(s):
-#// 
-#// Alternatively, the contents of this file may be used under the
-#// terms of the GNU General Public License Version 2 or later (the
-#// "GPL"), in which case the provisions of the GPL are applicable 
-#// instead of those above.  If you wish to allow use of your 
-#// version of this file only under the terms of the GPL and not to
-#// allow others to use your version of this file under the MPL,
-#// indicate your decision by deleting the provisions above and
-#// replace them with the notice and other provisions required by
-#// the GPL.  If you do not delete the provisions above, a recipient
-#// may use your version of this file under either the MPL or the
-#// GPL.
-#// 
-IGNORE_MANIFEST=1
-#//------------------------------------------------------------------------
-#//
-#// Makefile to build the ssl library
-#//
-#//------------------------------------------------------------------------
-
-!if "$(MOZ_BITS)" == "16"
-!ifndef MOZ_DEBUG
-OPTIMIZER=-Os -UDEBUG -DNDEBUG
-!endif
-!endif
-
-#//------------------------------------------------------------------------
-#//
-#// Specify the depth of the current directory relative to the
-#// root of NS
-#//
-#//------------------------------------------------------------------------
-DEPTH= ..\..\..\..
-
-!ifndef MAKE_OBJ_TYPE
-MAKE_OBJ_TYPE=EXE
-!endif
-
-#//------------------------------------------------------------------------
-#//
-#// Define any Public Make Variables here: (ie. PDFFILE, MAPFILE, ...)
-#//
-#//------------------------------------------------------------------------
-LIBNAME=cmt
-PDBFILE=$(LIBNAME).pdb
-
-LINCS = -I$(PUBLIC)\security \
-	-I$(PUBLIC)\nspr \
-        -I$(DEPTH)\include \
-	-I..\include
-
-!ifndef OS_CONFIG
-OS_CONFIG = WIN$(MOZ_BITS)
-!endif
-
-LCFLAGS = -DEXPORT_VERSION -DLIB_BUILD
-
-#//------------------------------------------------------------------------
-#// 
-#// Define the files necessary to build the target (ie. OBJS)
-#//
-#//------------------------------------------------------------------------
-OBJS=                         \
-    .\$(OBJDIR)\cmtinit.obj  \
-    .\$(OBJDIR)\cmtssl.obj   \
-    .\$(OBJDIR)\cmtutils.obj  \
-    .\$(OBJDIR)\cmtpkcs7.obj \
-    .\$(OBJDIR)\cmthash.obj \
-    .\$(OBJDIR)\cmtcert.obj \
-    .\$(OBJDIR)\cmtres.obj \
-    .\$(OBJDIR)\cmtjs.obj \
-    .\$(OBJDIR)\cmtevent.obj \
-    .\$(OBJDIR)\cmtpasswd.obj \
-    .\$(OBJDIR)\cmtadvisor.obj \
-    .\$(OBJDIR)\cmtrng.obj \
-	.\$(OBJDIR)\cmtsdr.obj \
-    $(NULL)
-
-#//------------------------------------------------------------------------
-#//
-#// Define any Public Targets here (ie. PROGRAM, LIBRARY, DLL, ...)
-#// (these must be defined before the common makefiles are included)
-#//
-#//------------------------------------------------------------------------
-LIBRARY=.\$(OBJDIR)\$(LIBNAME).lib
-
-#//------------------------------------------------------------------------
-#//
-#// install headers
-#//
-#//------------------------------------------------------------------------
-INSTALL_DIR=$(PUBLIC)\security
-INSTALL_FILE_LIST=cmtcmn.h cmtjs.h cmtclist.h
-
-#//------------------------------------------------------------------------
-#//
-#// Include the common makefile rules
-#//
-#//------------------------------------------------------------------------
-include <$(DEPTH)/config/rules.mak>
-
-install:: $(LIBRARY)
-    $(MAKE_INSTALL) $(LIBRARY) $(DIST)\lib
-
-export:: INSTALL_FILES
-

mozilla/security/psm/lib/client/manifest.mn

@@ -1,64 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-# 
-
-CORE_DEPTH = ../../..
-DEPTH = ../../..
-
-EXPORTS = \
-	cmtcmn.h \
-	cmtjs.h  \
-	cmtclist.h \
-	$(NULL)
-
-MODULE = security
-
-CSRCS = cmtinit.c  \
-	cmtssl.c   \
-	cmtutils.c \
-	cmtcert.c  \
-	cmthash.c  \
-	cmtpkcs7.c \
-	cmtres.c   \
-	cmtjs.c    \
-	cmtevent.c \
-        cmtpasswd.c \
-	cmtadvisor.c \
-	cmtrng.c \
-	cmtsdr.c \
-	$(NULL)
-
-REQUIRES = nspr security
-
-LIBRARY_NAME = cmt
-
-INCLUDES += -I$(CORE_DEPTH)/include

mozilla/security/psm/lib/client/sample/Makefile

@@ -1,128 +0,0 @@
-#! gmake
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-# 
-
-#######################################################################
-# (1) Include initial platform-independent assignments (MANDATORY).   #
-#######################################################################
-
-include manifest.mn
-
-#######################################################################
-# (2) Include "global" configuration information. (OPTIONAL)          #
-#######################################################################
-
-include $(CORE_DEPTH)/coreconf/config.mk
-
-#######################################################################
-# (3) Include "component" configuration information. (OPTIONAL)       #
-#######################################################################
-
-#######################################################################
-# (4) Include "local" platform-dependent assignments (OPTIONAL).      #
-#######################################################################
-
-ifneq ($(OS_ARCH), WINNT)
-ifeq ($(OS_ARCH), Linux)
-# On linux, we link with libstdc++
-CPLUSPLUSRUNTIME = -L /usr/lib -lstdc++ -lm
-else
-# libC, presumably, is what we must link with elsewhere
-CPLUSPLUSRUNTIME = -lC -lm
-endif
-endif
-
-ifeq ($(OS_ARCH), SunOS)
-ifeq ($(OS_RELEASE), 5.5.1)
-OS_LIBS += -ldl -lsocket -lnsl -lthread -lposix4
-endif
-ifeq ($(OS_RELEASE), 5.6)
-OS_LIBS += -ldl -lsocket -lnsl -lthread -lposix4
-endif
-endif
-
-ifeq ($(OS_ARCH), Linux)
-ifdef USE_PTHREADS
-# Replace OS_LIBS, because the order of libpthread, libdl, and libc are
-# very important. Otherwise you get horrible crashes.
-OS_LIBS = -lpthread -ldl -lc
-endif
-endif
-
-
-#######################################################################
-# (5) Execute "global" rules. (OPTIONAL)                              #
-#######################################################################
-
-include $(CORE_DEPTH)/coreconf/rules.mk
-
-#######################################################################
-# (6) Execute "component" rules. (OPTIONAL)                           #
-#######################################################################
-
-
-#######################################################################
-# (7) Execute "local" rules. (OPTIONAL).                              #
-#######################################################################
-
-ifeq ($(OS_ARCH), WINNT)
-LDFLAGS += /NODEFAULTLIB:library
-endif
-
-EXTRA_LIBS = \
-	$(DIST)/lib/$(LIB_PREFIX)cmt.$(LIB_SUFFIX) \
-	$(DIST)/lib/$(LIB_PREFIX)protocol.$(LIB_SUFFIX) \
-	$(NULL)
-
-ifeq ($(OS_ARCH), WINNT)
-EXTRA_LIBS += 	wsock32.lib \
-		winmm.lib \
-		$(NULL)
-endif
-
-link:
-	if test -f $(PROGRAM); then	\
-		echo "rm $(PROGRAM)";	\
-		rm $(PROGRAM);		\
-	fi;				\
-	gmake				\
-
-build_sample:
-ifneq ($(OS_ARCH),WINNT)
-	cd $(CORE_DEPTH)/coreconf; gmake
-endif
-	cd $(CORE_DEPTH)/security; gmake import; gmake export
-	cd ../../protocol; gmake
-	cd ..; gmake
-	gmake
-

mozilla/security/psm/lib/client/sample/appsock.c

@@ -1,250 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include "cmtcmn.h"
-#include "appsock.h"
-
-#ifdef XP_UNIX
-#include <netinet/tcp.h>
-#include <errno.h>
-#endif
-
-CMT_SocketFuncs socketFuncs = {
-    APP_GetSocket,
-    APP_Connect,
-    APP_VerifyUnixSocket,
-    APP_Send,
-    APP_Select,
-    APP_Receive,
-    APP_Shutdown,
-    APP_Close
-};
-
-CMTSocket APP_GetSocket(int unixSock)
-{
-    APPSocket *sock;
-    int on = 1;
-
-#ifndef XP_UNIX
-    if (unixSock) {
-        return NULL;
-    }
-#endif
-
-    sock = malloc(sizeof(APPSocket));
-    if (sock == NULL) {
-        return NULL;
-    }
-    if (unixSock) {
-        sock->sock = socket(AF_UNIX, SOCK_STREAM, 0);
-    } else {
-        sock->sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    }
-    if (sock->sock < 0) {
-        free(sock);
-        return NULL;
-    }
-    if (!unixSock && 
-        setsockopt(sock->sock, IPPROTO_TCP, TCP_NODELAY, (const char*)&on,
-                   sizeof(on))) {
-        free(sock);
-        return NULL;
-    }
-
-    sock->isUnix = unixSock;
-#ifdef XP_UNIX
-    memset (&sock->servAddr, 0, sizeof(struct sockaddr_un));
-#endif
-    return (CMTSocket)sock;
-}
-
-CMTStatus APP_Connect(CMTSocket sock, short port, char *path)
-{
-    APPSocket *cmSock = (APPSocket*)sock;
-    struct sockaddr_in iServAddr;
-    const struct sockaddr *servAddr;
-    size_t addrLen;
-    int error;
-
-    if (cmSock->isUnix){
-#ifndef XP_UNIX
-        return CMTFailure;
-#else
-        cmSock->servAddr.sun_family = AF_UNIX;
-	memcpy(&cmSock->servAddr.sun_path, path, strlen(path)+1);
-        servAddr = (const struct sockaddr*)&cmSock->servAddr;
-        addrLen = sizeof(cmSock->servAddr);
-#endif
-    } else {
-        iServAddr.sin_family = AF_INET;
-        iServAddr.sin_port = htons(port);
-        iServAddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
-        servAddr = (const struct sockaddr*)&iServAddr;
-        addrLen = sizeof(struct sockaddr_in);
-    }
-    while (connect(cmSock->sock, servAddr, addrLen) != 0) {
-#ifdef WIN32
-        error = WSAGetLastError();
-        if (error == WSAEISCONN) {
-            break;
-        }
-        if ((error != WSAEINPROGRESS) && (error != WSAEWOULDBLOCK) && 
-            (error!= WSAEINVAL)) {
-            goto loser;
-        }
-#else
-        error = errno;
-        if (error == EISCONN) {
-            break;
-        }
-        if (error != EINPROGRESS) {
-            goto loser;
-        }
-#endif
-    }
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus APP_VerifyUnixSocket(CMTSocket sock)
-{
-#ifndef XP_UNIX
-    return CMTFailure;
-#else
-    APPSocket *cmSock = (APPSocket*)sock;
-    int rv;
-    struct stat statbuf;
-
-    if (!cmSock->isUnix) {
-        return CMTFailure;
-    }
-    rv = stat(cmSock->servAddr.sun_path, &statbuf);
-    if (rv < 0) {
-        goto loser;
-    }
-    if (statbuf.st_uid != geteuid()) {
-        goto loser;
-    }
-    return CMTSuccess;
- loser:
-    close(cmSock->sock);
-    free(cmSock);
-    return CMTFailure;
-#endif
-}
-
-size_t APP_Send(CMTSocket sock, void *buffer, size_t length)
-{
-    APPSocket *cmSock = (APPSocket*) sock;
-
-    return send(cmSock->sock, buffer, length, 0);
-}
-
-CMTSocket APP_Select(CMTSocket *socks, int numsocks, int poll)
-{
-    APPSocket **sockArr = (APPSocket**)socks;
-    SOCKET nsocks = 0;
-    int i, rv;
-    struct timeval timeout;
-    fd_set readfds;
-
-#ifdef WIN32
-win_startover:
-#endif
-    FD_ZERO(&readfds);
-    for (i=0; i<numsocks; i++) {
-        FD_SET(sockArr[i]->sock, &readfds);
-        if (sockArr[i]->sock > nsocks) {
-            nsocks = sockArr[i]->sock;
-        }
-    }
-    if (poll) {
-        timeout.tv_sec = 0;
-        timeout.tv_usec = 0;
-    }
-    rv = select(nsocks+1, &readfds, NULL, NULL, (poll) ? &timeout : NULL);
-
-#ifdef WIN32
-    /* XXX Win95/98 Bug (Q177346)
-     *     select() with no timeout might return even if there is no data
-     *     pending or no error has occurred.  To get around this problem,
-     *     we loop if these erroneous conditions happen.
-     */
-    if (poll == 0 && rv == 0) {
-        goto win_startover;
-    }
-#endif
-
-    /* Figure out which socket was selected */
-    if (rv == -1 || rv == 0) {
-        goto loser;
-    }
-    for (i=0; i<numsocks; i++) {
-        if (FD_ISSET(sockArr[i]->sock, &readfds)) {
-            return (CMTSocket)sockArr[i];
-        }
-    }
- loser:
-    return NULL;
-}
-
-size_t APP_Receive(CMTSocket sock, void *buffer, size_t bufSize)
-{
-    APPSocket *cmSock = (APPSocket*)sock;
-
-    return recv(cmSock->sock, buffer, bufSize, 0);
-}
-
-CMTStatus APP_Shutdown(CMTSocket sock)
-{
-    APPSocket *cmSock = (APPSocket*)sock;
-    int rv;
-
-    rv = shutdown(cmSock->sock, 1);
-    return (rv == 0) ? CMTSuccess : CMTFailure;
-}
-
-CMTStatus APP_Close(CMTSocket sock)
-{
-    APPSocket *cmSock = (APPSocket*)sock;
-    int rv;
-
-#ifdef XP_UNIX
-    rv = close(cmSock->sock);
-#else
-    rv = closesocket(cmSock->sock);
-#endif
-    free(cmSock);
-    return (rv == 0) ? CMTSuccess : CMTFailure;
-}

mozilla/security/psm/lib/client/sample/appsock.h

@@ -1,69 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifndef _APPSOCK_H_
-#define _APPSOCK_H_
-#include "cmtcmn.h"
-
-#ifdef XP_UNIX
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <sys/un.h>
-#include <sys/stat.h>
-
-typedef int SOCKET;
-#endif
-
-typedef struct APPSocketStr {
-    SOCKET sock;
-    int    isUnix;
-#ifdef XP_UNIX
-    struct sockaddr_un servAddr;
-#endif 
-} APPSocket; 
-
-extern CMT_SocketFuncs socketFuncs;
-
-CMTStatus APP_Close(CMTSocket sock);
-CMTStatus APP_Shutdown(CMTSocket sock);
-size_t APP_Receive(CMTSocket sock, void *buffer, size_t bufSize);
-CMTSocket APP_Select(CMTSocket *socks, int numsocks, int poll);
-size_t APP_Send(CMTSocket sock, void *buffer, size_t length);
-CMTStatus APP_VerifyUnixSocket(CMTSocket sock);
-CMTStatus APP_Connect(CMTSocket sock, short port, char *path);
-CMTSocket APP_GetSocket(int unixSock);
-
-
-#endif /* _APPSOCK_H_ */

mozilla/security/psm/lib/client/sample/config.mk

@@ -1,44 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-# 
-
-#
-#  Override TARGETS variable so that only static libraries
-#  are specifed as dependencies within rules.mk.
-#
-
-TARGETS        = $(PROGRAM)
-SHARED_LIBRARY =
-IMPORT_LIBRARY =
-PURE_LIBRARY   =
-LIBRARY        =
-

mozilla/security/psm/lib/client/sample/manifest.mn

@@ -1,52 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-# 
-CORE_DEPTH = ../../../../..
-
-# MODULE public and private header  directories are implicitly REQUIRED.
-MODULE	= cmtsample
-
-EXPORTS = \
-	$(NULL)
-
-CSRCS = \
-	sample.c \
-	appsock.c \
-	$(NULL)
-INCLUDES += -I../../protocol -I..
-
-# The MODULE is always implicitly required.
-# Listing it here in REQUIRES makes it appear twice in the cc command line.
-REQUIRES = security
-
-PROGRAM  = cmtsample
-

mozilla/security/psm/lib/client/sample/sample.c

@@ -1,346 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include "cmtcmn.h"
-#include "cmtjs.h"
-#include "appsock.h"
-#include <stdarg.h>
-#include <string.h>
-
-#ifdef XP_UNIX
-#include <netdb.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#endif
-
-#ifdef WIN32
-#include <direct.h>
-#endif
-
-/*
- * This is a simple program that tries to detect if the psm server is loaded.
- * If the server is not loaded, it will start it.  The program will then 
- * connect to the server and fetch an HTML page from an SSL server.
- *
- * NOTE: This sample program does not implement a mutex for the libraries.
- * If implementing a threaded application, then pass in a mutex structure
- * so that connections to the psm server happen in a thread safe manner.
- */
-
-#define NUM_CONNECT_TRIES 10
-#define READ_BUFFER_SIZE  1024
-void
-usage(void)
-{
-    printf("Usage:\n"
-           "\tcmtsample <secure site>\n\n"
-           "This program will then echo the retrieved HTML to the screen\n");
-}
-
-void
-errorMessage(int err,char *msg, ...)
-{
-    va_list args;
-    
-    va_start(args, msg);
-    fprintf (stderr, "cmtSample%s: ", (err) ? " error" : "");
-    vfprintf (stderr, msg, args);
-    fprintf (stderr, "\n");
-    va_end(args);
-    if (err) {
-        exit (err);
-    }
-}
-
-#ifdef XP_UNIX
-#define FILE_PATH_SEPARATOR '/'
-#elif defined (WIN32)
-#define FILE_PATH_SEPARATOR '\\'
-#else
-#error Tell me what the file path separator is.
-#endif
-
-PCMT_CONTROL
-connect_to_psm(void)
-{
-    PCMT_CONTROL control=NULL;
-    char path[256], *tmp;
-
-#ifdef XP_UNIX
-    if (getcwd(path,256) == NULL) {
-      return NULL;
-    }
-#elif defined(WIN32)
-    if (_getcwd(path,256) == NULL) {
-      return NULL;
-    }
-#else
-#error Teach me how to get the current working directory.
-#endif
-    tmp = &path[strlen(path)];
-    sprintf(tmp,"%c%s", FILE_PATH_SEPARATOR, "psm");
-    return CMT_EstablishControlConnection(path, &socketFuncs, NULL);
-}
-
-#define HTTPS_STRING "https://"
-
-char*
-extract_host_from_url(char *url)
-{
-    char *start, *end, *retString=NULL;
-
-    while(isspace(*url)) {
-        url++;
-    }
-    url = strdup(url);
-    start = strstr(url, HTTPS_STRING);
-    if (start == NULL) {
-        return NULL;
-    }
-    start += strlen(HTTPS_STRING);
-    /*
-     * Figure out the end of the host name.
-     */
-    end = strchr(start, ':');
-    if (end != NULL) {
-        *end = '\0';
-    } else {
-        end = strchr(start, '/');
-        if (end != NULL) {
-            *end = '\0';
-        } else {
-            end = strchr(start, ' ');
-            if (end != NULL) {
-                *end = '\0';
-            }
-        }
-    }
-    retString = strdup(start);
-    return retString;
-}
-
-CMUint32
-get_port_from_url(char *url)
-{
-    char *colon, *port;
-
-    url = strdup(url);
-    colon = strrchr(url, ':');
-    if (colon == NULL ||
-        !isdigit(colon[1])) {
-        /* Return the default SSL port. */
-        free(url);
-        return 443;
-    }
-    colon++;
-    port = colon;
-    while(isdigit(*colon))
-        colon++;
-    colon[1] = '\0';
-    free(url);
-    return (CMUint32)atol(port);
-}
-
-char*
-extract_get_target(char *url)
-{
-    char *slash;
-
-    slash = strstr(url, "//");
-    slash += 2;
-    slash = strchr(slash, '/');
-    if (slash != NULL)
-        return strdup (slash);
-    else 
-        return strdup ("/");
-}
-
-/*
- * We'll use this function for prompting for a password.
- */
-char*
-passwordCallback(void *arg, char *prompt, void *cotext, int isPaswd)
-{
-    char input[256];
-    
-    printf(prompt);
-    fgets(input, 256, stdin);
-
-    return strdup(input);
-}
-
-void
-freeCallback(char *userInput)
-{
-  free (userInput);
-}
-
-#define NUM_PREFS 2
-
-int 
-main(int argc, char **argv)
-{
-  PCMT_CONTROL control;
-    CMTSocket sock, selSock;
-    char *hostname;
-    struct hostent *host;
-    char *ipAddress;
-    char buffer[READ_BUFFER_SIZE];
-    size_t bytesRead;
-    struct sockaddr_in destAddr;
-    char *getString;
-    char requestString[256];
-    char *profile;
-    CMTSetPrefElement prefs[NUM_PREFS];
-    char profileDir[256];
-
-#ifdef WIN32
-    WORD WSAVersion = 0x0101;
-    WSADATA WSAData;
-
-    WSAStartup (WSAVersion, &WSAData);
-#endif
-
-    if (argc < 2) {
-        usage();
-        return 1;
-    }
-    errorMessage (0,"cmtsample v1.0");
-    errorMessage (0,"Will try connecting to site %s", argv[1]);
-    if (strstr(argv[1], "https://") == NULL) {
-        errorMessage(2,"%s is not a secure site", argv[1]);
-    }
-    control = connect_to_psm();
-    if (control == NULL) {
-        errorMessage(3, "Could not connect to the psm server");
-    }
-    /* 
-     * Now we have to send the hello message.
-     */
-
-#ifdef WIN32
-    profile = strdup("default");
-    sprintf(profileDir,"%s", "c:\\default");
-#elif defined (XP_UNIX)
-    profile = getenv("LOGNAME");
-    sprintf(profileDir, "%s/.netscape", getenv("HOME"));
-#else
-#error Teach me how to fill in the user profile.
-#endif
-    if (CMT_Hello(control, PROTOCOL_VERSION,
-		  profile, profileDir) != CMTSuccess)
-    {
-        errorMessage(10, "Failed to send the Hello Message.");
-    }
-    CMT_SetPromptCallback(control, passwordCallback, NULL);
-    CMT_SetAppFreeCallback(control, freeCallback);
-    /*
-     * Now pass along some preferences to psm.  We'll pass hard coded
-     * ones here, but apps should figure out a way to manage their user's
-     * preferences.
-     */
-    prefs[0].key   = "security.enable_ssl2";
-    prefs[0].value = "true";
-    prefs[0].type  = CMT_PREF_BOOL;
-    prefs[1].key   = "security.enable_ssl3";
-    prefs[1].value = "true";
-    prefs[1].type  = CMT_PREF_BOOL;
-    CMT_PassAllPrefs(control, NUM_PREFS, prefs);
-    hostname = extract_host_from_url(argv[1]);
-    host = gethostbyname(hostname);
-    if (host == NULL) {
-        errorMessage(11, "gethostbyname for %s failed", hostname);
-    }
-    if (host->h_length != 4) {
-        errorMessage(4, "Site %s uses IV v6 socket.  Not supported by psm.");
-    }
-    
-    /* Create the socket we will use to get the decrypted data back from
-     * the psm server.
-     */
-    sock = APP_GetSocket(0);
-    if (sock == NULL) {
-        errorMessage(5, "Could not create new socket for communication with "
-                        "the psm server.");
-    }
-    memcpy(&(destAddr.sin_addr.s_addr), host->h_addr, host->h_length);
-    ipAddress = inet_ntoa(destAddr.sin_addr);
-    errorMessage(0, "Mapped %s to the following IP address: %s", argv[1],
-                 ipAddress);
-
-    if (CMT_OpenSSLConnection(control, sock, SSM_REQUEST_SSL_DATA_SSL,
-                              get_port_from_url(argv[1]), ipAddress, 
-                              hostname, CM_FALSE, NULL) != CMTSuccess) {
-        errorMessage(6, "Could not open SSL connection to %s.", argv[1]);
-    }
-
-    getString = extract_get_target(argv[1]);
-    sprintf(requestString, 
-            "GET %s HTTP/1.0\r\n"
-            "\r\n", getString, hostname);
-    APP_Send(sock, requestString, strlen(requestString));
-    /*
-     * Now all we have to do is sit here and fetch the data from the
-     * socket.
-     */
-    errorMessage (0, "About to print out the fetched page.");
-    while ((selSock=APP_Select(&sock, 1, 0)) != NULL) {
-        if (selSock == sock) {
-            bytesRead = APP_Receive(sock, buffer, READ_BUFFER_SIZE-1);
-            if (bytesRead == -1 || bytesRead == 0) {
-                break;
-            }
-            buffer[bytesRead] = '\0';
-            fprintf(stderr, buffer);
-        }
-    }
-    fprintf(stderr,"\n");
-    if (bytesRead == -1) {
-        errorMessage(7, "Error receiving decrypted data from psm.");
-    }
-    errorMessage(0, "Successfully read the entire page.");
-    if (CMT_DestroyDataConnection(control, sock) != CMTSuccess) {
-        errorMessage(8, "Error destroygin the SSL data connection "
-                     "with the psm server.");
-    }
-    if (CMT_CloseControlConnection(control) != CMTSuccess) {
-        errorMessage(9, "Error closing the control connection.");
-    }
-    return 0;
-}
-
-
-
-

mozilla/security/psm/lib/client/test.c

@@ -1,99 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include "cmt.h"
-
-CMTStatus myCallback(CMTControl * control, CMTItem * event, void * arg);
-
-int main(int argc, char ** argv)
-{
-  CMTItem * msg, * event = NULL;
-  CMTStatus status;
-  int socket, datasocket;
-  int sent;
-  CMTControl * connect;
-  char * buffer = "some weird text that I feel like passing to server";
-  
-  connect = CMT_ControlConnect(myCallback, event);
-  
-  msg = CMT_ConstructMessage(10);
-
-  msg->type = (int)CMTClientMessage;
-  sprintf((char *)msg->data, "first msg!");
-
-  status = CMT_SendMessage(connect, msg, event);
-  if (status != SECSuccess)
-    perror("CMT_SendMessage");
-  
-  CMT_FreeEvent(event);
-  event = NULL;
-
-  sprintf((char *)msg->data, "second msg");
-  status = CMT_SendMessage(connect, msg, event);
-  if (status != SECSuccess)
-    perror("CMT_SendMessage");
-
-  datasocket = CMT_DataConnect(connect, NULL);
-  if (datasocket < 0) 
-    perror("CMT_DataConnect");
-  
-  sent = write(datasocket, (void *)buffer, strlen(buffer));
-  sent = write(datasocket, (void *)buffer, strlen(buffer));
-
-  close(datasocket);
-  
-  msg->type = (int)CMTClientMessage;
-  sprintf((char *)msg->data, "third msg!");
-  status = CMT_SendMessage(connect, msg, event);
-  if (status != SECSuccess)
-    perror("CMT_SendMessage"); 
-  
-  status = CMT_CloseControlConnection(connect);
-  if (status != SECSuccess)
-    perror("CMT_CloseControl");
-  
-  CMT_FreeMessage(msg);
-  CMT_FreeEvent(event);
-}
-
-CMTStatus myCallback(CMTControl * control, CMTItem * event, void * arg)
-{
-  if (event) 
-    printf("Event received is : type %d, data %s\n", event->type, event->data);
-  else printf("No event!\n");
-  if (arg) 
-    printf("Arg is %s\n", (char *)arg);
-  else printf("No arg!\n");
-
-
-  return SECSuccess;
-}

mozilla/security/psm/lib/macbuild/PSMPrefix.h

@@ -1,3 +0,0 @@
-
-
-#include "MacPrefix.h"

mozilla/security/psm/lib/macbuild/PSMPrefix_debug.h

@@ -1,2 +0,0 @@
-
-#include "MacPrefix_debug.h"

mozilla/security/psm/lib/makefile.win

@@ -1,27 +0,0 @@
-#!nmake
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-
-DEPTH=..\..\..
-include <$(DEPTH)/config/config.mak>
-
-DIRS = client protocol
-
-include <$(DEPTH)\config\rules.mak>

mozilla/security/psm/lib/manifest.mn

@@ -1,43 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-# 
-#
-
-CORE_DEPTH = ../..
-DEPTH      = ../..
-
-DIRS = protocol client
-
-#
-# these dirs are not built at the moment
-#
-#NOBUILD_DIRS = jar

mozilla/security/psm/lib/protocol/MANIFEST

@@ -1,3 +0,0 @@
-obscure.h
-rsrcids.h
-ssmdefs.h

mozilla/security/psm/lib/protocol/Makefile

@@ -1,74 +0,0 @@
-#! gmake
-#
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-#
-
-#######################################################################
-# (1) Include initial platform-independent assignments (MANDATORY).   #
-#######################################################################
-
-include manifest.mn
-
-#######################################################################
-# (2) Include "global" configuration information. (OPTIONAL)          #
-#######################################################################
-
-include $(CORE_DEPTH)/coreconf/config.mk
-
-#######################################################################
-# (3) Include "component" configuration information. (OPTIONAL)       #
-#######################################################################
-
-
-
-#######################################################################
-# (4) Include "local" platform-dependent assignments (OPTIONAL).      #
-#######################################################################
-include config.mk
-
-
-#######################################################################
-# (5) Execute "global" rules. (OPTIONAL)                              #
-#######################################################################
-
-include $(CORE_DEPTH)/coreconf/rules.mk
-
-#######################################################################
-# (6) Execute "component" rules. (OPTIONAL)                           #
-#######################################################################
-
-
-
-#######################################################################
-# (7) Execute "local" rules. (OPTIONAL).                              #
-#######################################################################
-

mozilla/security/psm/lib/protocol/Makefile.in

@@ -1,64 +0,0 @@
-#! gmake
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-#
-
-DEPTH		= ../../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-LIBRARY_NAME = protocol
-MODULE = security
-
-EXPORTS = \
-	protocol.h \
-	protocolf.h \
-	protocolport.h \
-	protocolnspr20.h \
-	protocolshr.h \
-	ssmdefs.h \
-	rsrcids.h \
-	messages.h \
-	newproto.h \
-	$(NULL)
-
-
-CSRCS  = newproto.c \
-	 templates.c \
-	 protocolshr.c \
-	 $(NULL)
-
-include $(topsrcdir)/config/rules.mk
-

mozilla/security/psm/lib/protocol/config.mk

@@ -1,44 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-# 
-
-#
-#  Override TARGETS variable so that only static libraries
-#  are specifed as dependencies within rules.mk.
-#
-
-TARGETS        = $(LIBRARY)
-SHARED_LIBRARY =
-IMPORT_LIBRARY =
-PURE_LIBRARY   =
-PROGRAM        =
-

mozilla/security/psm/lib/protocol/makefile.win

@@ -1,124 +0,0 @@
-#// 
-#// The contents of this file are subject to the Mozilla Public
-#// License Version 1.1 (the "License"); you may not use this file
-#// except in compliance with the License. You may obtain a copy of
-#// the License at http://www.mozilla.org/MPL/
-#// 
-#// Software distributed under the License is distributed on an "AS
-#// IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-#// implied. See the License for the specific language governing
-#// rights and limitations under the License.
-#// 
-#// The Original Code is the Netscape security libraries.
-#// 
-#// The Initial Developer of the Original Code is Netscape
-#// Communications Corporation.  Portions created by Netscape are 
-#// Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-#// Rights Reserved.
-#// 
-#// Contributor(s):
-#// 
-#// Alternatively, the contents of this file may be used under the
-#// terms of the GNU General Public License Version 2 or later (the
-#// "GPL"), in which case the provisions of the GPL are applicable 
-#// instead of those above.  If you wish to allow use of your 
-#// version of this file only under the terms of the GPL and not to
-#// allow others to use your version of this file under the MPL,
-#// indicate your decision by deleting the provisions above and
-#// replace them with the notice and other provisions required by
-#// the GPL.  If you do not delete the provisions above, a recipient
-#// may use your version of this file under either the MPL or the
-#// GPL.
-#// 
-IGNORE_MANIFEST=1
-#//------------------------------------------------------------------------
-#//
-#// Makefile to build the ssl library
-#//
-#//------------------------------------------------------------------------
-
-!if "$(MOZ_BITS)" == "16"
-!ifndef MOZ_DEBUG
-OPTIMIZER=-Os -UDEBUG -DNDEBUG
-!endif
-!endif
-
-#//------------------------------------------------------------------------
-#//
-#// Specify the depth of the current directory relative to the
-#// root of NS
-#//
-#//------------------------------------------------------------------------
-DEPTH= ..\..\..\..
-
-!ifndef MAKE_OBJ_TYPE
-MAKE_OBJ_TYPE=EXE
-!endif
-
-#//------------------------------------------------------------------------
-#//
-#// Define any Public Make Variables here: (ie. PDFFILE, MAPFILE, ...)
-#//
-#//------------------------------------------------------------------------
-LIBNAME=protocol
-PDBFILE=$(LIBNAME).pdb
-
-LINCS = -I$(PUBLIC)\security \
-	-I$(PUBLIC)\nspr \
-        -I$(DEPTH)\include \
-	-I..\include
-
-!ifndef OS_CONFIG
-OS_CONFIG = WIN$(MOZ_BITS)
-!endif
-
-LCFLAGS = -DEXPORT_VERSION -DLIB_BUILD
-
-#//------------------------------------------------------------------------
-#// 
-#// Define the files necessary to build the target (ie. OBJS)
-#//
-#//------------------------------------------------------------------------
-OBJS=                         \
-    .\$(OBJDIR)\newproto.obj  \
-    .\$(OBJDIR)\templates.obj \
-    .\$(OBJDIR)\protocolshr.obj \
-    $(NULL)
-
-#//------------------------------------------------------------------------
-#//
-#// Define any Public Targets here (ie. PROGRAM, LIBRARY, DLL, ...)
-#// (these must be defined before the common makefiles are included)
-#//
-#//------------------------------------------------------------------------
-LIBRARY=.\$(OBJDIR)\$(LIBNAME).lib
-
-#//------------------------------------------------------------------------
-#//
-#// install headers
-#//
-#//------------------------------------------------------------------------
-INSTALL_DIR=$(PUBLIC)\security
-INSTALL_FILE_LIST= protocol.h \
-   protocolf.h \
-   protocolport.h \
-   protocolnspr20.h \
-   protocolshr.h \
-   ssmdefs.h \
-   rsrcids.h \
-   messages.h \
-   newproto.h \
-   $(NULL)
-
-#//------------------------------------------------------------------------
-#//
-#// Include the common makefile rules
-#//
-#//------------------------------------------------------------------------
-include <$(DEPTH)/config/rules.mak>
-
-install:: $(LIBRARY)
-    $(MAKE_INSTALL) $(LIBRARY) $(DIST)\lib
-
-export:: INSTALL_FILES
-

mozilla/security/psm/lib/protocol/manifest.mn

@@ -1,65 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-# 
-
-CORE_DEPTH = ../../..
-
-EXPORTS = \
-	protocol.h \
-	protocolf.h \
-	protocolport.h \
-	protocolnspr20.h \
-	protocolshr.h \
-	ssmdefs.h \
-	rsrcids.h \
-	messages.h \
-	newproto.h \
-	$(NULL)
-
-MODULE = security
-CSRCS  = newproto.c \
-	 protocolshr.c \
-	 templates.c \
-	 $(NULL)
-
-ifeq ($(subst /,_,$(shell uname -s)),OS2)
-	CSRCS += os2_rand.c
-endif
-
-#	mac_rand.c
-#	unix_rand.c
-#	win_rand.c
-#	prelib.c
-
-REQUIRES = security dbm nspr
-
-LIBRARY_NAME = protocol

mozilla/security/psm/lib/protocol/messages.h

@@ -1,620 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifndef __MESSAGES_H__
-#define __MESSAGES_H__
-
-#include "newproto.h"
-
-typedef struct SingleNumMessage {
-  CMInt32 value;
-} SingleNumMessage;
-
-extern CMTMessageTemplate SingleNumMessageTemplate[];
-
-typedef struct SingleStringMessage {
-  char *string;
-} SingleStringMessage;
-
-extern CMTMessageTemplate SingleStringMessageTemplate[];
-
-typedef struct SingleItemMessage {
-  CMTItem item;
-} SingleItemMessage;
-
-extern CMTMessageTemplate SingleItemMessageTemplate[];
-
-typedef struct HelloRequest {
-  CMInt32 version;
-  CMInt32 policy;
-  CMBool doesUI;
-  char *profile;
-  char* profileDir;
-} HelloRequest;
-
-extern CMTMessageTemplate HelloRequestTemplate[];
-
-typedef struct HelloReply {
-  CMInt32 result;
-  CMInt32 sessionID;
-  CMInt32 version;
-  CMInt32 httpPort;
-  CMInt32 policy;
-  CMTItem nonce;
-  char *stringVersion;
-} HelloReply;
-
-extern CMTMessageTemplate HelloReplyTemplate[];
-
-typedef struct SSLDataConnectionRequest {
-  CMInt32 flags;
-  CMInt32 port;
-  char *hostIP;
-  char *hostName;
-  CMBool forceHandshake;
-  CMTItem clientContext;
-} SSLDataConnectionRequest;
-
-extern CMTMessageTemplate SSLDataConnectionRequestTemplate[];
-
-typedef struct TLSDataConnectionRequest {
-    CMInt32 port;
-    char* hostIP;
-    char* hostName;
-} TLSDataConnectionRequest;
-
-extern CMTMessageTemplate TLSDataConnectionRequestTemplate[];
-
-typedef struct TLSStepUpRequest {
-    CMUint32 connID;
-    CMTItem clientContext;
-} TLSStepUpRequest;
-
-extern CMTMessageTemplate TLSStepUpRequestTemplate[];
-
-typedef struct ProxyStepUpRequest {
-    CMUint32 connID;
-    CMTItem clientContext;
-    char* url;
-} ProxyStepUpRequest;
-
-extern CMTMessageTemplate ProxyStepUpRequestTemplate[];
-
-typedef struct PKCS7DataConnectionRequest {
-    CMUint32 resID;
-    CMTItem clientContext;
-} PKCS7DataConnectionRequest;
-
-extern CMTMessageTemplate PKCS7DataConnectionRequestTemplate[];
-
-typedef struct DataConnectionReply {
-  CMInt32 result;
-  CMInt32 connID;
-  CMInt32 port;
-} DataConnectionReply;
-
-extern CMTMessageTemplate DataConnectionReplyTemplate[];
-
-typedef struct UIEvent {
-  CMInt32 resourceID;
-  CMInt32 width;
-  CMInt32 height;
-  CMBool isModal;
-  char *url;
-  CMTItem clientContext;
-} UIEvent;
-
-extern CMTMessageTemplate UIEventTemplate[];
-extern CMTMessageTemplate OldUIEventTemplate[];
-
-typedef struct TaskCompletedEvent {
-  CMInt32 resourceID;
-  CMInt32 numTasks;
-  CMInt32 result;
-} TaskCompletedEvent;
-
-extern CMTMessageTemplate TaskCompletedEventTemplate[];
-
-typedef struct VerifyDetachedSigRequest {
-  CMInt32 pkcs7ContentID;
-  CMInt32 certUsage;
-  CMInt32 hashAlgID;
-  CMBool keepCert;
-  CMTItem hash;
-} VerifyDetachedSigRequest;
-
-extern CMTMessageTemplate VerifyDetachedSigRequestTemplate[];
-
-typedef struct CreateSignedRequest {
-  CMInt32 scertRID;
-  CMInt32 ecertRID;
-  CMInt32 dig_alg;
-  CMTItem digest;
-} CreateSignedRequest;
-
-extern CMTMessageTemplate CreateSignedRequestTemplate[];
-
-typedef struct CreateContentInfoReply {
-  CMInt32 ciRID;
-  CMInt32 result;
-  CMInt32 errorCode;
-} CreateContentInfoReply;
-
-extern CMTMessageTemplate CreateContentInfoReplyTemplate[];
-
-typedef struct CreateEncryptedRequest {
-  CMInt32 scertRID;
-  CMInt32 nrcerts;
-  CMInt32 *rcertRIDs;
-} CreateEncryptedRequest;
-
-extern CMTMessageTemplate CreateEncryptedRequestTemplate[];
-
-typedef struct CreateResourceRequest {
-  CMInt32 type;
-  CMTItem params;
-} CreateResourceRequest;
-
-extern CMTMessageTemplate CreateResourceRequestTemplate[];
-
-typedef struct CreateResourceReply {
-  CMInt32 result;
-  CMInt32 resID;
-} CreateResourceReply;
-
-extern CMTMessageTemplate CreateResourceReplyTemplate[];
-
-typedef struct GetAttribRequest {
-  CMInt32 resID;
-  CMInt32 fieldID;
-} GetAttribRequest;
-
-extern CMTMessageTemplate GetAttribRequestTemplate[];
-
-typedef struct GetAttribReply {
-  CMInt32 result;
-  SSMAttributeValue value;
-} GetAttribReply;
-
-extern CMTMessageTemplate GetAttribReplyTemplate[];
-
-typedef struct SetAttribRequest {
-  CMInt32 resID;
-  CMInt32 fieldID;
-  SSMAttributeValue value;
-} SetAttribRequest;
-
-extern CMTMessageTemplate SetAttribRequestTemplate[];
-
-typedef struct PickleResourceReply {
-    CMInt32 result;
-    CMTItem blob;
-} PickleResourceReply;
-
-extern CMTMessageTemplate PickleResourceReplyTemplate[];
-
-typedef struct UnpickleResourceRequest {
-  CMInt32 resourceType;
-  CMTItem resourceData;
-} UnpickleResourceRequest;
-
-extern CMTMessageTemplate UnpickleResourceRequestTemplate[];
-
-typedef struct UnpickleResourceReply {
-    CMInt32 result;
-    CMInt32 resID;
-} UnpickleResourceReply;
-
-extern CMTMessageTemplate UnpickleResourceReplyTemplate[];
-
-typedef struct PickleSecurityStatusReply {
-    CMInt32 result;
-    CMInt32 securityLevel;
-    CMTItem blob;
-} PickleSecurityStatusReply;
-
-extern CMTMessageTemplate PickleSecurityStatusReplyTemplate[];
-
-typedef struct DupResourceReply {
-    CMInt32 result;
-    CMUint32 resID;
-} DupResourceReply;
-
-extern CMTMessageTemplate DupResourceReplyTemplate[];
-
-typedef struct DestroyResourceRequest {
-  CMInt32 resID;
-  CMInt32 resType;
-} DestroyResourceRequest;
-
-extern CMTMessageTemplate DestroyResourceRequestTemplate[];
-
-typedef struct VerifyCertRequest {
-  CMInt32 resID;
-  CMInt32 certUsage;
-} VerifyCertRequest;
-
-extern CMTMessageTemplate VerifyCertRequestTemplate[];
-
-typedef struct AddTempCertToDBRequest {
-  CMInt32 resID;
-  char *nickname;
-  CMInt32 sslFlags;
-  CMInt32 emailFlags;
-  CMInt32 objSignFlags;
-} AddTempCertToDBRequest;
-
-extern CMTMessageTemplate AddTempCertToDBRequestTemplate[];
-
-typedef struct MatchUserCertRequest {
-  CMInt32 certType;
-  CMInt32 numCANames;
-  char **caNames;
-} MatchUserCertRequest;
-
-extern CMTMessageTemplate MatchUserCertRequestTemplate[];
-
-typedef struct MatchUserCertReply {
-  CMInt32 numCerts;
-  CMInt32 *certs;
-} MatchUserCertReply;
-
-extern CMTMessageTemplate MatchUserCertReplyTemplate[];
-
-typedef struct EncodeCRMFReqRequest {
-    CMInt32 numRequests;
-    CMInt32 * reqIDs;
-} EncodeCRMFReqRequest;
-
-extern CMTMessageTemplate EncodeCRMFReqRequestTemplate[];
-
-typedef struct CMMFCertResponseRequest {
-    char *nickname;
-    char *base64Der;
-    CMBool doBackup;
-    CMTItem clientContext;
-} CMMFCertResponseRequest;
-
-extern CMTMessageTemplate CMMFCertResponseRequestTemplate[];
-
-typedef struct PasswordRequest {
-    CMInt32 tokenKey;
-    char *prompt;
-    CMTItem clientContext;
-} PasswordRequest;
-
-extern CMTMessageTemplate PasswordRequestTemplate[];
-
-typedef struct PasswordReply {
-    CMInt32 result;
-    CMInt32 tokenID;
-    char * passwd;
-} PasswordReply;
-
-extern CMTMessageTemplate PasswordReplyTemplate[];
-
-typedef struct KeyPairGenRequest {
-    CMInt32 keyGenCtxtID;
-    CMInt32 genMechanism;
-    CMInt32 keySize;
-    CMTItem params;
-} KeyPairGenRequest;
-
-extern CMTMessageTemplate KeyPairGenRequestTemplate[];
-
-typedef struct DecodeAndCreateTempCertRequest {
-    CMInt32 type;
-    CMTItem cert;
-} DecodeAndCreateTempCertRequest;
-
-extern CMTMessageTemplate DecodeAndCreateTempCertRequestTemplate[];
-
-typedef struct GenKeyOldStyleRequest {
-    char *choiceString;
-    char *challenge;
-    char *typeString;
-    char *pqgString;
-} GenKeyOldStyleRequest;
-
-extern CMTMessageTemplate GenKeyOldStyleRequestTemplate[];
-
-typedef struct GenKeyOldStyleTokenRequest {
-    CMInt32 rid;
-    CMInt32 numtokens;
-    char ** tokenNames;
-} GenKeyOldStyleTokenRequest;
-
-extern CMTMessageTemplate GenKeyOldStyleTokenRequestTemplate[];
-
-typedef struct GenKeyOldStyleTokenReply {
-    CMInt32 rid;
-    CMBool cancel;
-    char * tokenName;
-} GenKeyOldStyleTokenReply;
-
-extern CMTMessageTemplate GenKeyOldStyleTokenReplyTemplate[];
-
-typedef struct GenKeyOldStylePasswordRequest {
-    CMInt32 rid;
-    char * tokenName;
-    CMBool internal;
-    CMInt32 minpwdlen;
-    CMInt32 maxpwdlen;
-} GenKeyOldStylePasswordRequest;
-
-extern CMTMessageTemplate GenKeyOldStylePasswordRequestTemplate[];
-
-typedef struct GenKeyOldStylePasswordReply {
-    CMInt32 rid;
-    CMBool cancel;
-    char * password;
-} GenKeyOldStylePasswordReply;
-
-extern CMTMessageTemplate GenKeyOldStylePasswordReplyTemplate[];
-
-typedef struct GetKeyChoiceListRequest {
-    char *type;
-    char *pqgString;
-} GetKeyChoiceListRequest;
-
-extern CMTMessageTemplate GetKeyChoiceListRequestTemplate[];
-
-typedef struct GetKeyChoiceListReply {
-    CMInt32 nchoices;
-    char **choices;
-} GetKeyChoiceListReply;
-
-extern CMTMessageTemplate GetKeyChoiceListReplyTemplate[];
-
-typedef struct AddNewSecurityModuleRequest {
-    char *moduleName;
-    char *libraryPath;
-    CMInt32 pubMechFlags;
-    CMInt32 pubCipherFlags;
-} AddNewSecurityModuleRequest;
-
-extern CMTMessageTemplate AddNewSecurityModuleRequestTemplate[];
-
-typedef struct FilePathRequest {
-    CMInt32 resID;
-    char *prompt;
-    CMBool getExistingFile;
-    char *fileRegEx;
-} FilePathRequest;
-
-extern CMTMessageTemplate FilePathRequestTemplate[];
-
-typedef struct FilePathReply {
-    CMInt32 resID;
-    char *filePath;
-} FilePathReply;
-
-extern CMTMessageTemplate FilePathReplyTemplate[];
-
-typedef struct PasswordPromptReply {
-    CMInt32 resID;
-    char *promptReply;
-} PasswordPromptReply;
-
-extern CMTMessageTemplate PasswordPromptReplyTemplate[];
-
-typedef struct SignTextRequest {
-    CMInt32 resID;
-    char *stringToSign;
-    char *hostName;
-    char *caOption;
-    CMInt32 numCAs;
-    char** caNames;
-} SignTextRequest;
-
-extern CMTMessageTemplate SignTextRequestTemplate[];
-
-typedef struct GetLocalizedTextReply {
-    CMInt32 whichString;
-    char *localizedString;
-} GetLocalizedTextReply;
-
-extern CMTMessageTemplate GetLocalizedTextReplyTemplate[];
-
-typedef struct ImportCertReply {
-    CMInt32 result;
-    CMInt32 resID;
-} ImportCertReply;
-
-extern CMTMessageTemplate ImportCertReplyTemplate[];
-
-typedef struct PromptRequest {
-    CMInt32 resID;
-    char *prompt;
-    CMTItem clientContext;
-} PromptRequest;
-
-extern CMTMessageTemplate PromptRequestTemplate[];
-
-typedef struct PromptReply {
-    CMInt32 resID;
-    CMBool cancel;
-    char *promptReply;
-} PromptReply;
-
-extern CMTMessageTemplate PromptReplyTemplate[];
-
-typedef struct RedirectCompareReqeust {
-    CMTItem socketStatus1Data;
-    CMTItem socketStatus2Data;
-} RedirectCompareRequest;
-
-extern CMTMessageTemplate RedirectCompareRequestTemplate[];
-
-typedef struct DecodeAndAddCRLRequest {
-    CMTItem  derCrl;
-    CMUint32 type;
-    char *url;
-} DecodeAndAddCRLRequest;
-
-extern CMTMessageTemplate DecodeAndAddCRLRequestTemplate[];
-
-typedef struct SecurityAdvisorRequest {
-    CMInt32 infoContext;
-    CMInt32 resID;
-    char * hostname;
-	char * senderAddr;
-    CMUint32 encryptedP7CInfo;
-    CMUint32 signedP7CInfo;
-    CMInt32 decodeError;
-    CMInt32 verifyError;
-	CMBool encryptthis;
-	CMBool signthis;
-	CMInt32 numRecipients;
-	char ** recipients;
-} SecurityAdvisorRequest;
-
-extern CMTMessageTemplate SecurityAdvisorRequestTemplate[];
-
-/* "SecurityConfig" javascript related message templates */
-typedef struct SCAddTempCertToPermDBRequest {
-    CMTItem certKey;
-    char* trustStr;
-    char* nickname;
-} SCAddTempCertToPermDBRequest;
-
-extern CMTMessageTemplate SCAddTempCertToPermDBRequestTemplate[];
-
-typedef struct SCDeletePermCertsRequest {
-    CMTItem certKey;
-    CMBool deleteAll;
-} SCDeletePermCertsRequest;
-
-extern CMTMessageTemplate SCDeletePermCertsRequestTemplate[];
-
-typedef struct TimeMessage {
-    CMInt32 year;
-    CMInt32 month;
-    CMInt32 day;
-    CMInt32 hour;
-    CMInt32 minute;
-    CMInt32 second;
-} TimeMessage;
-
-extern CMTMessageTemplate TimeMessageTemplate[];
-
-typedef struct CertEnumElement {
-    char* name;
-    CMTItem certKey;
-} CertEnumElement;
-
-typedef struct SCCertIndexEnumReply {
-      int length;
-      CertEnumElement* list;
-} SCCertIndexEnumReply;
-
-extern CMTMessageTemplate SCCertIndexEnumReplyTemplate[];
-
-/* Test message */
-typedef struct TestListElement {
-	char * name;
-	char * value;
-} TestListElement;
-
-typedef struct TestList {
-	char *listName;
-	int numElements;
-	TestListElement *elements;
-} TestList;
-
-extern CMTMessageTemplate TestListTemplate[];
-
-/* Preference-related structs */
-typedef struct SetPrefElement {
-    char* key;
-    char* value;
-    CMInt32 type;
-} SetPrefElement;
-
-typedef struct SetPrefListMessage {
-    int length;
-    SetPrefElement* list;
-} SetPrefListMessage;
-
-extern CMTMessageTemplate SetPrefListMessageTemplate[];
-
-typedef struct GetPrefElement {
-    char* key;
-    CMInt32 type;
-} GetPrefElement;
-
-typedef struct GetPrefListRequest {
-    int length;
-    GetPrefElement* list;
-} GetPrefListRequest;
-
-extern CMTMessageTemplate GetPrefListRequestTemplate[];
-
-typedef struct GetCertExtension {
-    CMUint32 resID;
-    CMUint32 extension;
-} GetCertExtension;
-
-extern CMTMessageTemplate GetCertExtensionTemplate[];
-
-typedef struct HTMLCertInfoRequest {
-    CMUint32 certID;
-    CMUint32 showImages;
-    CMUint32 showIssuer;
-} HTMLCertInfoRequest;
-
-extern CMTMessageTemplate HTMLCertInfoRequestTemplate[];
-
-typedef struct EncryptRequestMessage
-{
-  CMTItem keyid;  /* May have length 0 for default */
-  CMTItem data;
-  CMTItem ctx;  /* serialized void* ptr */
-} EncryptRequestMessage;
-
-extern CMTMessageTemplate EncryptRequestTemplate[];
-
-typedef struct SingleItemMessage EncryptReplyMessage;
-#define EncryptReplyTemplate SingleItemMessageTemplate
-
-typedef struct DecryptRequestMessage
-{
-  CMTItem data;
-  CMTItem ctx;  /* serialized void* ptr */
-} DecryptRequestMessage;
-extern CMTMessageTemplate DecryptRequestTemplate[];
-
-typedef struct SingleItemMessage DecryptReplyMessage;
-#define DecryptReplyTemplate SingleItemMessageTemplate
-
-#endif /* __MESSAGES_H__ */

mozilla/security/psm/lib/protocol/newproto.c

@@ -1,602 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include <string.h>
-#include <assert.h>
-#ifdef WIN32
-#include <winsock.h>
-#endif
-#ifdef XP_MAC
-#include "macsocket.h"
-#endif
-
-#include "newproto.h"
-
-char SSMVersionString[] = "1.1";
-
-CMT_Alloc_fn cmt_alloc = malloc;
-CMT_Free_fn cmt_free = free;
-
-#define ASSERT(x) assert(x)
-
-#define CM_ntohl ntohl
-#define CM_htonl htonl
-
-
-/*************************************************************
- *
- * CMT_Init
- *
- *
- ************************************************************/
-void
-CMT_Init(CMT_Alloc_fn allocfn, CMT_Free_fn freefn)
-{
-    cmt_alloc = allocfn;
-    cmt_free = freefn;
-}
-
-static CMTStatus
-decode_int(unsigned char **curptr, void *dest, CMInt32 *remaining)
-{
-    CMInt32 datalen = sizeof(CMInt32);
-
-    if (*remaining < datalen)
-        return CMTFailure;
-    *(CMInt32 *)dest = ntohl(**(CMInt32 **)curptr);
-    *remaining -= datalen;
-    *curptr += datalen;
-    return CMTSuccess;
-}
-
-static CMTStatus
-decode_string(unsigned char **curptr, CMInt32 *len,
-              unsigned char **data, CMInt32 *remaining)
-{
-    CMTStatus rv;
-    CMInt32 datalen;
-
-    rv = decode_int(curptr, len, remaining);
-    if (rv != CMTSuccess)
-        return CMTFailure;
-
-    /* NULL string */
-    if (*len == 0) {
-        *data = NULL;
-        goto done;
-    }
-
-    datalen = (*len + 3) & ~3;
-    if (*remaining < datalen)
-        return CMTFailure;
-
-    *data = (unsigned char *) cmt_alloc(*len + 1);
-    if (*data == NULL)
-        return CMTFailure;
-
-    memcpy(*data, *curptr, *len);
-    (*data)[*len] = 0;
-    *remaining -= datalen;
-    *curptr += datalen;
-done:
-    return CMTSuccess;
-}
-
-/*************************************************************
- * CMT_DecodeMessage
- *
- * Decode msg into dest as specified by tmpl.
- *
- ************************************************************/
-CMTStatus
-CMT_DecodeMessage(CMTMessageTemplate *tmpl, void *dest, CMTItem *msg)
-{
-    unsigned char *curptr, *destptr, *list;
-	void ** ptr;
-    CMInt32 remaining, len, choiceID = 0, listSize, listCount = 0;
-    CMBool inChoice = CM_FALSE, foundChoice = CM_FALSE, inList = CM_FALSE;
-    CMInt32 listItemSize = 0;
-    CMTStatus rv = CMTSuccess;
-	CMTMessageTemplate *startOfList, *p;
-	CMBool inStructList = CM_FALSE;
-
-    curptr = msg->data;
-    remaining = msg->len;
-
-    while(tmpl->type != CMT_DT_END) {
-        /* XXX Maybe this should be a more formal state machine? */
-        if (inChoice) {
-            if (tmpl->type == CMT_DT_END_CHOICE) {
-                if (!foundChoice)
-                    goto loser;
-                inChoice = CM_FALSE;
-                foundChoice = CM_FALSE;
-                tmpl++;
-                continue;
-            }
-            if (choiceID != tmpl->choiceID) {
-                tmpl++;
-                continue;  /* Not this option */
-            } else {
-                foundChoice = CM_TRUE;
-            }
-        }
-        if (inList) {
-            destptr = &list[listCount * listItemSize];
-            listCount++;
-        } else {
-			if (inStructList) {
-				destptr = tmpl->offset + list;
-			} else {
-				destptr = tmpl->offset + (unsigned char *)dest;
-			}
-        }
-        switch (tmpl->type) {
-          case CMT_DT_RID:
-          case CMT_DT_INT:
-          case CMT_DT_BOOL:
-            rv = decode_int(&curptr, destptr, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            break;
-          case CMT_DT_STRING:
-            rv = decode_string(&curptr, &len, (unsigned char **)destptr,
-                               &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            break;
-          case CMT_DT_ITEM:
-            rv = decode_string(&curptr, (long *) &((CMTItem *)destptr)->len,
-                               &((CMTItem *)destptr)->data, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            break;
-          case CMT_DT_LIST:
-            /* XXX This is too complicated */
-            rv = decode_int(&curptr, destptr, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            listSize = *(CMInt32 *)destptr;
-            tmpl++;
-            if (tmpl->type == CMT_DT_STRING) {
-                listItemSize = sizeof(unsigned char *);
-            } else if (tmpl->type == CMT_DT_ITEM) {
-                listItemSize = sizeof(CMTItem);
-            } else {
-                listItemSize = sizeof(CMInt32);
-            }
-            if (listSize == 0) {
-                list = NULL;
-            } else {
-                list = (unsigned char *) cmt_alloc(listSize * listItemSize);
-            }
-            *(void **)(tmpl->offset + (unsigned char *)dest) = list;
-            inList = CM_TRUE;
-            listCount = 0;
-            break;
-          case CMT_DT_STRUCT_LIST:
-            /* XXX This is too complicated */
-            rv = decode_int(&curptr, destptr, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            listSize = *(CMInt32 *)destptr;
-            tmpl++;
-			if (tmpl->type != CMT_DT_STRUCT_PTR) {
-				goto loser;
-			}
-			ptr = (void**)(tmpl->offset + (unsigned char *)dest);
-			startOfList = tmpl;
-			p = tmpl;
-			listItemSize = 0;
-			while (p->type != CMT_DT_END_STRUCT_LIST) {
-				if (p->type == CMT_DT_STRING) {
-					listItemSize += sizeof(unsigned char *);
-				} else if (p->type == CMT_DT_ITEM) {
-					listItemSize += sizeof(CMTItem);
-				} else if (p->type == CMT_DT_INT) {
-	                listItemSize += sizeof(CMInt32);
-		        }
-				p++;
-			}
-            if (listSize == 0) {
-                list = NULL;
-            } else {
-                list = (unsigned char *) cmt_alloc(listSize * listItemSize);
-            }
-            *ptr = list;
-            inStructList = CM_TRUE;
-            listCount = 0;
-            break;
-		  case CMT_DT_END_STRUCT_LIST:
-			listCount++;
-			if (listCount == listSize) {
-				inStructList = CM_FALSE;
-			} else {
-				list += listItemSize;
-				tmpl = startOfList;
-			}
-			break;
-          case CMT_DT_CHOICE:
-            rv = decode_int(&curptr, destptr, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            choiceID = *(CMInt32 *)destptr;
-            inChoice = CM_TRUE;
-            foundChoice = CM_FALSE;
-            break;
-          case CMT_DT_END_CHOICE: /* Loop should exit before we see these. */
-          case CMT_DT_END:
-          default:
-            ASSERT(0);
-            break;
-        }
-        if (inList) {
-            if (listCount == listSize) {
-                inList = CM_FALSE;
-                tmpl++;
-            }
-        } else {
-            tmpl++;
-        }
-    }
-loser:
-    /* Free the data buffer */
-    if (msg->data) {
-        cmt_free(msg->data);
-        msg->data = NULL;
-    }
-    return rv;
-}
-
-static CMTStatus
-calc_msg_len(CMTMessageTemplate *tmpl, void *src, CMInt32 *len_out)
-{
-    CMInt32 len = 0, choiceID = 0, listSize, listItemSize, listCount;
-    unsigned char *srcptr, *list;
-    CMBool inChoice = CM_FALSE, inList = CM_FALSE, foundChoice = CM_FALSE;
-	CMTMessageTemplate *startOfList, *p;
-	CMBool inStructList = CM_FALSE;
-
-    while(tmpl->type != CMT_DT_END) {
-        if (inChoice) {
-            if (tmpl->type == CMT_DT_END_CHOICE) {
-                if (!foundChoice)
-                    goto loser;
-                inChoice = CM_FALSE;
-                foundChoice = CM_FALSE;
-                tmpl++;
-                continue;
-            }
-            if (choiceID != tmpl->choiceID) {
-                tmpl++;
-                continue;  /* Not this option */
-            } else {
-                foundChoice = CM_TRUE;
-            }
-        }
-        if (inList) {
-            srcptr = &list[listCount * listItemSize];
-            listCount++;
-        } else if (inStructList) {
-			srcptr = tmpl->offset + list;
-		} else {
-            srcptr = tmpl->offset + (unsigned char *)src;
-        }
-        switch(tmpl->type) {
-          case CMT_DT_RID:
-          case CMT_DT_INT:
-          case CMT_DT_BOOL:
-            len += sizeof(CMInt32);
-            break;
-          case CMT_DT_STRING:
-            len += sizeof(CMInt32);
-            /* Non NULL string */
-            if (*(char**)srcptr) {
-                len += (strlen(*(char**)srcptr) + 4) & ~3;
-            }
-            break;
-          case CMT_DT_ITEM:
-            len += sizeof(CMInt32);
-            len += (((CMTItem *)srcptr)->len + 3) & ~3;
-            break;
-          case CMT_DT_LIST:
-            len += sizeof(CMInt32);
-            listSize = *(CMInt32 *)srcptr;
-            tmpl++;
-            if (tmpl->type == CMT_DT_STRING) {
-                listItemSize = sizeof(unsigned char *);
-            } else if (tmpl->type == CMT_DT_ITEM) {
-                listItemSize = sizeof(CMTItem);
-            } else {
-                listItemSize = sizeof(CMInt32);
-            }
-            list = *(unsigned char **)(tmpl->offset + (unsigned char *)src);
-            listCount = 0;
-            inList = CM_TRUE;
-            break;
-		  case CMT_DT_STRUCT_LIST:
-			len += sizeof(CMInt32);
-			listSize = *(CMInt32 *)srcptr;
-			tmpl++;
-			if (tmpl->type != CMT_DT_STRUCT_PTR) {
-				goto loser;
-			}
-			list = *(unsigned char**)(tmpl->offset + (unsigned char*)src);
-			startOfList = tmpl;
-			p = tmpl;
-			listItemSize = 0;
-			while (p->type != CMT_DT_END_STRUCT_LIST) {
-				if (p->type == CMT_DT_STRING) {
-					listItemSize += sizeof(unsigned char *);
-				} else if (p->type == CMT_DT_ITEM) {
-					listItemSize += sizeof(CMTItem);
-				} else if (p->type == CMT_DT_INT) {
-					listItemSize += sizeof(CMInt32);
-				}
-				p++;
-			}
-			listCount = 0;
-			inStructList = CM_TRUE;
-			break;
-		  case CMT_DT_END_STRUCT_LIST:
-			listCount++;
-			if (listCount == listSize) {
-				inStructList = CM_FALSE;
-			} else {
-				list += listItemSize;
-				tmpl = startOfList;
-			}
-			break;
-          case CMT_DT_CHOICE:
-            len += sizeof(CMInt32);
-            choiceID = *(CMInt32 *)srcptr;
-            inChoice = CM_TRUE;
-            foundChoice = CM_FALSE;
-            break;
-          case CMT_DT_END_CHOICE: /* Loop should exit before we see these. */
-          case CMT_DT_END:
-          default:
-            ASSERT(0);
-            break;
-        }
-        if (inList) {
-            if (listCount == listSize) {
-                inList = CM_FALSE;
-                tmpl++;
-            }
-        } else {
-            tmpl++;
-        }
-    }
-    *len_out = len;
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-
-static CMTStatus
-encode_int(unsigned char **curptr, void *src, CMInt32 *remaining)
-{
-    CMInt32 datalen = sizeof(CMInt32);
-
-    if (*remaining < datalen)
-        return CMTFailure;
-    **(CMInt32 **)curptr = CM_htonl(*(CMInt32 *)src);
-    *remaining -= datalen;
-    *curptr += datalen;
-    return CMTSuccess;
-}
-
-static CMTStatus
-encode_string(unsigned char **curptr, CMInt32 len,
-              unsigned char *data, CMInt32 *remaining)
-{
-    CMTStatus rv;
-    CMInt32 datalen;
-
-    rv = encode_int(curptr, &len, remaining);
-    if (rv != CMTSuccess)
-        return CMTFailure;
-
-    /* NULL string */
-    if (len == 0) {
-        goto done;
-    }
-
-    datalen = (len + 3) & ~3;
-    if (*remaining < datalen)
-        return CMTFailure;
-
-    memcpy(*curptr, data, len);
-    *remaining -= datalen;
-    *curptr += datalen;
-done:
-    return CMTSuccess;
-}
-
-/*************************************************************
- * CMT_EncodeMessage
- *
- * Encode src into msg as specified by tmpl.
- *
- ************************************************************/
-CMTStatus
-CMT_EncodeMessage(CMTMessageTemplate *tmpl, CMTItem *msg, void *src)
-{
-    CMInt32 choiceID = 0, listSize, listItemSize, listCount, remaining;
-    unsigned char *srcptr, *curptr, *list;
-    CMBool inChoice = CM_FALSE, inList = CM_FALSE, foundChoice = CM_FALSE;
-    CMTStatus rv = CMTSuccess;
-	CMTMessageTemplate *startOfList, *p;
-	CMBool inStructList = CM_FALSE;
-
-    rv = calc_msg_len(tmpl, src, (long *) &msg->len);
-    if (rv != CMTSuccess)
-        goto loser;
-    curptr = msg->data = (unsigned char *) cmt_alloc(msg->len);
-    if(msg->data == NULL)
-        goto loser;
-    remaining = msg->len;
-
-    while(tmpl->type != CMT_DT_END) {
-        if (inChoice) {
-            if (tmpl->type == CMT_DT_END_CHOICE) {
-                if (!foundChoice)
-                    goto loser;
-                inChoice = CM_FALSE;
-                foundChoice = CM_FALSE;
-                tmpl++;
-                continue;
-            }
-            if (choiceID != tmpl->choiceID) {
-                tmpl++;
-                continue;  /* Not this option */
-            } else {
-                foundChoice = CM_TRUE;
-            }
-        }
-        if (inList) {
-            srcptr = &list[listCount * listItemSize];
-            listCount++;
-        } else {
-			if (inStructList) {
-				srcptr = tmpl->offset + list;
-			} else {
-				srcptr = tmpl->offset + (unsigned char *)src;
-			}
-        }
-        switch(tmpl->type) {
-          case CMT_DT_RID:
-          case CMT_DT_INT:
-          case CMT_DT_BOOL:
-            rv = encode_int(&curptr, srcptr, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            break;
-          case CMT_DT_STRING:
-             if (*(char**)srcptr) {
-                 /* Non NULL string */
-                 rv = encode_string(&curptr, (long) strlen(*(char**)srcptr), 
-                 	                *(unsigned char**)srcptr, &remaining);
-             } else {
-                 /* NULL string */
-                 rv = encode_string(&curptr, 0L, *(unsigned char**)srcptr, &remaining);
-             }
-             if (rv != CMTSuccess)
-                goto loser;
-             break;
-          case CMT_DT_ITEM:
-            rv = encode_string(&curptr, ((CMTItem *)srcptr)->len,
-                               ((CMTItem *)srcptr)->data, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            break;
-          case CMT_DT_LIST:
-            rv = encode_int(&curptr, srcptr, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            listSize = *(CMInt32 *)srcptr;
-            tmpl++;
-            if (tmpl->type == CMT_DT_STRING) {
-                listItemSize = sizeof(unsigned char *);
-            } else if (tmpl->type == CMT_DT_ITEM) {
-                listItemSize = sizeof(CMTItem);
-            } else {
-                listItemSize = sizeof(CMInt32);
-            }
-            list = *(unsigned char **)(tmpl->offset + (unsigned char *)src);
-            listCount = 0;
-            inList = CM_TRUE;
-            break;
-		  case CMT_DT_STRUCT_LIST:
-            rv = encode_int(&curptr, srcptr, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            listSize = *(CMInt32 *)srcptr;
-			tmpl++;
-			if (tmpl->type != CMT_DT_STRUCT_PTR) {
-				goto loser;
-			}
-			list = *(unsigned char**)(tmpl->offset + (unsigned char*)src);
-			startOfList = tmpl;
-			p = tmpl;
-			listItemSize = 0;
-			while (p->type != CMT_DT_END_STRUCT_LIST) {
-				if (p->type == CMT_DT_STRING) {
-					listItemSize += sizeof(unsigned char *);
-				} else if (p->type == CMT_DT_ITEM) {
-					listItemSize += sizeof(CMTItem);
-				} else if (p->type == CMT_DT_INT) {
-					listItemSize += sizeof(CMInt32);
-				}
-				p++;
-			}
-			listCount = 0;
-			inStructList = CM_TRUE;
-			break;
-		  case CMT_DT_END_STRUCT_LIST:
-			listCount++;
-			if (listCount == listSize) {
-				inStructList = CM_FALSE;
-			} else {
-				list += listItemSize;
-				tmpl = startOfList;
-			}
-			break;
-          case CMT_DT_CHOICE:
-            rv = encode_int(&curptr, srcptr, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            choiceID = *(CMInt32 *)srcptr;
-            inChoice = CM_TRUE;
-            foundChoice = CM_FALSE;
-            break;
-          case CMT_DT_END_CHOICE: /* Loop should exit before we see these. */
-          case CMT_DT_END:
-          default:
-            ASSERT(0);
-            break;
-        }
-        if (inList) {
-            if (listCount == listSize) {
-                inList = CM_FALSE;
-                tmpl++;
-            }
-        } else {
-            tmpl++;
-        }
-    }
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}

mozilla/security/psm/lib/protocol/newproto.h

@@ -1,102 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifndef __NEWPROTO_H__
-#define __NEWPROTO_H__
-
-#include <stdlib.h>
-#include "ssmdefs.h"
-
-typedef enum CMTDataType {
-    CMT_DT_END,
-    CMT_DT_RID,
-    CMT_DT_INT,
-    CMT_DT_BOOL,
-    CMT_DT_STRING,
-    CMT_DT_ITEM,
-    CMT_DT_LIST,
-    CMT_DT_CHOICE,
-    CMT_DT_END_CHOICE,
-	CMT_DT_STRUCT_LIST,
-	CMT_DT_END_STRUCT_LIST,
-	CMT_DT_STRUCT_PTR
-} CMTDataType;
-
-typedef struct CMTMessageTemplate {
-    CMTDataType type;
-    CMUint32 offset;
-    CMInt32 validator;
-    CMInt32 choiceID;
-} CMTMessageTemplate;
-
-typedef struct CMTMessageHeader {
-    CMInt32 type;
-    CMInt32 len;
-} CMTMessageHeader;
-
-typedef void *(* CMT_Alloc_fn) (size_t size);
-typedef void (* CMT_Free_fn)(void * ptr);
-
-extern CMT_Alloc_fn cmt_alloc;
-extern CMT_Free_fn cmt_free;
-
-/*************************************************************
- *
- * CMT_Init
- *
- *
- ************************************************************/
-void
-CMT_Init(CMT_Alloc_fn allocfn, CMT_Free_fn freefn);
-
-/*************************************************************
- * CMT_DecodeMessage
- *
- * Decode msg into dest as specified by tmpl.
- *
- ************************************************************/
-CMTStatus
-CMT_DecodeMessage(CMTMessageTemplate *tmpl, void *dest, CMTItem *msg);
-
-
-/*************************************************************
- * CMT_EncodeMessage
- *
- * Encode src into msg as specified by tmpl.
- *
- ************************************************************/
-CMTStatus
-CMT_EncodeMessage(CMTMessageTemplate *tmpl, CMTItem *msg, void *src);
-
-
-#endif /* __NEWPROTO_H__ */

mozilla/security/psm/lib/protocol/obsample.c

@@ -1,187 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-/* SAMPLE CODE
-** Illustrates use of SSMObscure object methods.
-**
-** Author:  Nelson Bolyard	June 1999
-*/
-
-#include <stdio.h>
-#include "obscure.h"
-
-
-/* On error, returns -1.
-** On success, returns non-negative number of unobscured bytes in buf
-int
-RecvInitObscureData(int fd, SSMObscureObject * obj, void * buf, int bufSize )
-{
-    SSMObscureBool done = 0;
-
-    do {
-	int cc;
-	int rv;
-	cc = read(fd, buf, bufSize);
-	if (cc <= 0)
-	    return -1;
-	rv = SSMObscure_RecvInit(obj, buf, cc, &done);
-    } while (!done);
-    return rv;
-}
-
-
-/* returns -1 on error, 0 on success. */
-int
-SendInitObscureData(int fd, SSMObscureObject * obj)
-{
-    unsigned char * initBuf = NULL;
-    int             rv      = -1;
-
-    do {
-	int bufLen;
-	int len;
-	int cc;
-
-	bufLen = SSMObscure_SendInit(obj, NULL);
-	if (bufLen <= 0)
-	    break;
-
-	initBuf = malloc(bufLen);
-	if (!initBuf)
-	    break;
-
-	len = SSMObscure_SendInit(obj, initBuf);
-	if (len != bufLen)
-	    break;
-
-	cc = write(fd, initBuf, len);
-
-	/* Note, this code assumes a blocking socket, 
-	** and hence doesn't deal with short writes.
-	*/
-	if (cc < len) 
-	    break;
-
-    	rv = 0;
-
-    } while (0);
-
-    if (initBuf) {
-	free(initBuf);
-    	initBuf = NULL;
-    }
-    return rv;
-}
-
-/* This is like write, but it obscures the data first. */
-/* This code assumes a blocking socket, and so it doesn't handle short 
-** writes.
-*/
-int 
-obscuredWrite(SSMObscureObject * obj, int fd, void * buf, int len)
-{
-    int rv;
-    int cc;
-
-    cc = SSMObscure_Send(obj, buf, len);
-    if (cc <= 0)
-    	return cc;
-    rv = write(fd, buf, cc);
-    ASSERT(rv == cc || rv < 0);
-    return rv;
-}
-
-/* This is like read, but it unobscures the data after reading it. */
-int 
-obscuredRead(SSMObscureObject * obj, int fd, void * buf, int len)
-{
-    int rv;
-    int cc;
-
-    do {
-	cc = read(fd, buf, len);
-	if (cc <= 0)
-	    return cc;
-	rv = SSMObscure_Recv(obj, buf, len);
-    } while (rv == 0);
-    return rv;
-}
-
-SSMObscureObject * sobj;
-unsigned char buf[8192];
-
-/* Call this with fd for socket that has just been accepted.
-** returns -1 on error, 
-** On success, returns non-negative number of bytes received in buf. 
-*/
-int
-InitClientObscureObject(int fd) 
-{
-    int rv;
-
-    sobj = SSMObscure_Create(0);
-    if (!sobj)
-    	return -1;
-
-    rv = SendInitObscureData(fd, sobj);
-    if (rv < 0)
-    	return rv;
-
-    rv = RecvInitObscureData(fd, sobj, buf, sizeof buf);
-    return rv;
-}
-
-/* Call this with fd for socket that has just been connected.
-** returns -1 on error, 
-** On success, returns non-negative number of bytes received in buf. 
-*/
-int
-InitServerObscureObject(int fd)
-{
-    int cc;
-
-    sobj = SSMObscure_Create(1);
-    if (!sobj)
-    	return -1;
-
-    cc = RecvInitObscureData(fd, sobj, buf, sizeof buf);
-    if (cc < 0) 
-    	return cc;
-
-
-    rv = SendInitObscureData(fd, sobj);
-    if (rv < 0)
-    	return rv;
-
-    return cc;
-}
-

mozilla/security/psm/lib/protocol/obscure.c

@@ -1,136 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include <stdlib.h>
-#include "obspriv.h"
-#include "newproto.h"
-
-
-/* 
-** Create a new Obscuring object 
-*/
-SSMObscureObject * 
-SSMObscure_Create(SSMObscureBool IsServer)
-{
-    SSMObscureObject * obj;
-    void *             priv;
-
-    obj = (SSMObscureObject *) cmt_alloc(sizeof *obj);
-    if (!obj)
-    	return obj;
-    /* This needs to be a little more elegant */
-    priv = SSMObscure_InitPrivate(obj, IsServer);
-    if (!priv) {
-    	cmt_free(obj);
-	return NULL;
-    }
-    obj->privData = priv;
-    return obj;
-}
-
-
-/* Prepare initial buffer with initial message to send to other side to 
-** establish cryptographic * synchronization.
-**
-** If buf is NULL, function returns the size of the buffer that 
-** the caller needs to allocate for sending the initial message.
-** 
-** If buf is non-null, function returns the number of bytes of data filled 
-** into buf, the amount that the caller should then send to the other side.
-**
-*/
-int 
-SSMObscure_SendInit( SSMObscureObject * obj, void * buf)
-{
-    int rv;
-    rv = obj->sendInit(obj->privData, buf);
-    return rv;
-}
-
-/* 
-** Obscure "len" bytes in "buf" before sending it. 
-*/
-int 
-SSMObscure_Send(	SSMObscureObject * obj, 
-			void *             buf, 
-			unsigned int       len)
-{
-    int rv;
-    rv = obj->send(obj->privData, buf, len);
-    return rv;
-}
-
-/* 
-** UnObscure "len" bytes in "buf" after receiving it. 
-** This function may absorb some or all of the received bytes, leaving 
-** fewer bytes (possibly none) in the buffer for the application to use 
-** than were in the buffer when the function was called.
-** Function returns the number of bytes of unobscured data remaining in
-** buf.  Zero means all data was used internally and no data remains 
-** for application use. Negative number means error occurred.
-*/
-int 
-SSMObscure_Recv(	SSMObscureObject * obj, 
-			void *             buf, 
-			unsigned int       len)
-{
-    int rv;
-    rv = obj->recv(obj->privData, buf, len);
-    return rv;
-}
-
-/* like _Recv, but returns a flag telling when all initialization info has
-** been received.
-*/
-int 
-SSMObscure_RecvInit(	SSMObscureObject * obj, 
-			void *             buf, 
-			unsigned int       len,
-			SSMObscureBool   * done)
-{
-    int rv;
-    rv = obj->recvInit(obj->privData, buf, len, done);
-    return rv;
-}
-
-/* 
-** Destroy the Obscure Object 
-*/
-int 
-SSMObscure_Destroy(SSMObscureObject * obj)
-{
-    int rv;
-    rv = obj->destroy(obj->privData);
-    cmt_free(obj);
-    return rv;
-}
-

mozilla/security/psm/lib/protocol/obscure.h

@@ -1,98 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifndef __obscure_h__
-#define __obscure_h__ 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-typedef unsigned char SSMObscureBool;
-
-typedef struct SSMObscureObjectStr 	SSMObscureObject;
-
-/* 
-** Create a new Obscuring object 
-*/
-extern SSMObscureObject * SSMObscure_Create(SSMObscureBool IsServer);
-
-
-/* Prepare initial buffer with initial message to send to other side to 
-** establish cryptographic * synchronization.
-**
-** If buf is NULL, function returns the size of the buffer that 
-** the caller needs to allocate for sending the initial message.
-** 
-** If buf is non-null, function returns the number of bytes of data filled 
-** into buf, the amount that the caller should then send to the other side.
-**
-*/
-extern int SSMObscure_SendInit( SSMObscureObject * obj,
-				void *             buf);
-
-/* 
-** Obscure "len" bytes in "buf" before sending it. 
-*/
-extern int SSMObscure_Send(	SSMObscureObject * obj, 
-                            	void *             buf, 
-				unsigned int       len);
-
-/* 
-** UnObscure "len" bytes in "buf" after receiving it. 
-** This function may absorb some or all of the received bytes, leaving 
-** fewer bytes (possibly none) in the buffer for the application to use 
-** than were in the buffer when the function was called.
-** Function returns the number of bytes of unobscured data remaining in
-** buf.  Zero means all data was used internally and no data remains 
-** for application use. Negative number means error occurred.
-*/
-extern int SSMObscure_Recv(	SSMObscureObject * obj, 
-                                void *             buf, 
-				unsigned int       len);
-
-/* like _Recv, but returns a flag telling when all initialization info has
-** been received.
-*/
-extern int SSMObscure_RecvInit(	SSMObscureObject * obj, 
-                                void *             buf, 
-				unsigned int       len,
-				SSMObscureBool   * done);
-
-/* 
-** Destroy the Obscure Object 
-*/
-extern int SSMObscure_Destroy(SSMObscureObject * obj);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __obscure_h__ */

mozilla/security/psm/lib/protocol/obspriv.c

@@ -1,115 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include "obspriv.h"
-#include "newproto.h"
-#include <string.h>
-#include <assert.h>
-#include <time.h>
-
-/* 
-   Originally this code was used to obscure the control messages
-   traveling between processes. With the relaxation of export rules,
-   this whole step is no longer necessary, and is included for
-   informational purposes only. (We need to finish removing the 
-   obscuring code.)
-*/
-struct obscureNOPStr {
-    SSMObscureObject * obj;
-};
-
-typedef struct obscureNOPStr obscureV1;
-
-static int 
-ssmObscure_Destroy(void * privData)
-{
-    obscureV1 * priv = (obscureV1 *)privData;
-
-    memset(priv, 0, sizeof *priv);
-    cmt_free(priv);
-    return 0;
-}
-
-static int
-ssmObscure_Send(void * privData, void * buf, unsigned int len)
-{
-    /* obscureV1 *  priv 		= (obscureV1 *)privData;*/
-
-    /* NOP */
-    return len;
-}
-
-static int    
-ssmObscure_Recv(void * privData, void * buf, unsigned int len)
-{
-    /*obscureV1 *  priv 		= (obscureV1 *)privData;*/
-
-    /* NOP */
-    return len;
-}
-
-static int    
-ssmObscure_SendInit(void * privData, void * buf)
-{
-    /*obscureV1 *      priv = (obscureV1 *)privData;*/
-
-    return 0;
-}
-
-static int    
-ssmObscure_RecvInit(void * privData, void * buf, unsigned int len,
-                    SSMObscureBool * pDone)
-{
-    return 0;
-}
-
-static void *
-ssmObscure_InitPrivate(SSMObscureObject * obj, SSMObscureBool IsServer)
-{
-    obscureV1 *   priv 		= (obscureV1 *) cmt_alloc(sizeof (obscureV1));
-
-    if (!priv)
-    	return NULL;
-
-    priv->obj        = obj;
-
-    obj->privData  = (void *)priv;
-    obj->destroy  = ssmObscure_Destroy;
-    obj->send     = ssmObscure_Send;
-    obj->recv     = ssmObscure_Recv;
-    obj->sendInit = ssmObscure_SendInit;
-    obj->recvInit = ssmObscure_RecvInit;
-    
-    return priv;
-}
-
-obsInitFn SSMObscure_InitPrivate = ssmObscure_InitPrivate;

mozilla/security/psm/lib/protocol/obspriv.h

@@ -1,63 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include "obscure.h"
-
-typedef void * (* obsInitFn)    (SSMObscureObject * instance, 
-                                 SSMObscureBool     IsServer);
-typedef int    (* obsDestroyFn) (void * priv);
-typedef int    (* obsSendFn)    (void * priv, void * buf, unsigned int len);
-typedef int    (* obsRecvFn)    (void * priv, void * buf, unsigned int len);
-typedef int    (* obsSendInitFn)(void * priv, void * buf);
-typedef int    (* obsRecvInitFn)(void * priv, void * buf, unsigned int len,
-                                 SSMObscureBool * done);
-
-struct SSMObscureObjectStr {
-    void *	  privData;
-    obsDestroyFn  destroy;
-    obsSendFn     send;
-    obsRecvFn     recv;
-    obsSendInitFn sendInit;
-    obsRecvInitFn recvInit;
-};
-
-
-/* This is common to the beginning of all versions of the obscuring protocol */
-struct SSMInitMsgHdrStr {
-    short	version;
-    short	length;
-};
-
-typedef struct SSMInitMsgHdrStr SSMInitMsgHdr;
-
-extern obsInitFn SSMObscure_InitPrivate;
-

mozilla/security/psm/lib/protocol/protocol.h

@@ -1,141 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-/*
-  protocol.h - Definitions of various items to support the PSM protocol.
- */
-
-#ifndef __PROTOCOL_H__
-#define __PROTOCOL_H__
-
-
-#include "rsrcids.h"
-
-#define SSMPRStatus SSMStatus
-#define SSMPR_SUCCESS SSM_SUCCESS
-#define SSMPR_FAILURE SSM_FAILURE
-
-#define SSMPR_INVALID_ARGUMENT_ERROR PR_INVALID_ARGUMENT_ERROR
-#define SSMPR_OUT_OF_MEMORY_ERROR    PR_OUT_OF_MEMORY_ERROR
-
-#define SSMPRInt32 PRInt32
-#define SSMPRUint32 PRUint32
-
-#define SSMPR_ntohl  PR_ntohl
-#define SSMPR_htonl  PR_htonl
-#define SSMPORT_Free   PORT_Free
-#define SSMPORT_ZAlloc PORT_ZAlloc
-
-#define SSMPR_SetError PR_SetError
-#define SSMPR_GetError PR_GetError
-#define SSMPORT_SetError PORT_SetError
-#define SSMPORT_GetError PORT_GetError
-
-/* 
-   Current version of PSM protocol. 
-   Increment this value when the protocol changes. 
-*/
-
-#define SSMSTRING_PADDED_LENGTH(x) ((((x)+3)/4)*4)
-#define SSMPORT_ZNEW(type) (type*)SSMPORT_ZAlloc(sizeof(type))
-#define SSMPORT_ZNewArray(type,size) (type*)SSMPORT_ZAlloc(sizeof(type)*(size))
-/* Various message structs */
-
-struct _SSMHelloRequest {
-  CMUint32          m_version; /* Protocol version supported by client */
-  struct _SSMString m_profileName; /* Name of user profile (where to find 
-				 certs etc) */
-};
-
-struct _SSMHelloReply {
-  CMInt32           m_result; /* Error, if any, which occurred 
-				 (0 == success) */
-  CMUint32          m_version; /* Protocol version supported by PSM */
-  struct _SSMString m_nonce; /* Session nonce -- must be written to data channels */
-};
-
-struct _SSMRequestSSLDataConnection
-{
-  CMUint32          m_flags; /* Flags to indicate to SSM what to do with
-				the connection */
-  CMUint32          m_port; /* Port number to connect to */
-  struct _SSMString m_hostIP; /* IP address of final target machine (not proxy) */
-  /* struct _SSMString m_hostName; Host name of target machine (for server auth) -- not accessed directly */
-};
-
-struct _SSMReplySSLDataConnection {
-  CMInt32 m_result; /* Error, if any, which occurred (0 == success) */
-  CMUint32 m_connectionID; /* Connection ID of newly opened channel */
-  CMUint32 m_port; /* Port number to which to connect on PSM */
-};
-
-
-struct _SSMRequestSecurityStatus {
-  CMUint32 m_connectionID; /* ID of connection of which to stat */
-};
-
-struct _SSMReplySecurityStatus {
-  CMInt32 m_result; /* Error, if any, which occurred (0 == success) */
-  CMUint32 m_keySize; /* Key size */
-  CMUint32 m_secretKeySize; /* Secret key size */
-  struct _SSMString m_cipherName; /* Name of cipher in use */
-  /* SSMString m_certificate; -- DER encoded cert
-     We do not access this as a field, we have to skip over m_cipherName */
-};
-
-/* 
-   Use this macro to jump over strings.
-   For example, if you wanted to access m_certificate above, 
-   use a line like the following:
-
-   char *ptr = &(reply->m_cipherName) + SSM_SIZEOF_STRING(reply->m_cipherName);
-*/
-#define SSM_SIZEOF_STRING(str) (SSMSTRING_PADDED_LENGTH(PR_ntohl((str).m_length)) + sizeof(CMUint32))
-
-
-typedef struct _SSMHelloRequest SSMHelloRequest;
-typedef struct _SSMHelloReply SSMHelloReply;
-typedef struct _SSMRequestSSLDataConnection SSMRequestSSLDataConnection;
-typedef struct _SSMReplySSLDataConnection SSMReplySSLDataConnection;
-typedef struct _SSMRequestSecurityStatus SSMRequestSecurityStatus;
-typedef struct _SSMReplySecurityStatus SSMReplySecurityStatus;
-
-/* 
-   Functions to convert between an SSMString and a C string.
-   Return values are allocated using PR_Malloc (which means that
-   SSMPR_Free must be used to free up the memory after use). 
-*/
-CMTStatus SSM_StringToSSMString(SSMString ** ssmString, int len, char * string);
-CMTStatus SSM_SSMStringToString(char ** string,int *len, SSMString * ssmString);
-
-
-#endif /* __PROTOCOL_H__ */

mozilla/security/psm/lib/protocol/protocolf.h

@@ -1,359 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifndef __PROTOCOLF_H__
-#define __PROTOCOLF_H__
-/*************************************************************************
- * For each type of message, parse and pack function is provided. 
- *
- * Parse functions accept a ptr to the "blob" of data received from the 
- * network and fill in fields of the message, numbers in host-order, strings
- * as C-style NULL-terminated strings. Return SSMPRStatus. 
- *
- * Pack functions take all the info to construct a message and fill in a 
- * ptr to the "blob" of data to be sent. Return length of the data blob, or 
- * a zero in case of an error
- *
- * All functions set NSPR errors when necessary.
- ************************************************************************/
-#include "protocol.h"
-#include "cert.h"
-
-SSMPRStatus SSM_ParseHelloRequest(void * helloRequest, 
-				  SSMPRUint32 * version, 
-				  PRBool * doesUI,
-				  PRInt32 * policyType,
-				  SSMPRUint32 * profileLen,
-				  char ** profile);
-SSMPRInt32 SSM_PackHelloReply(void ** helloReply, SSMPRInt32 result, 
-			      SSMPRUint32 sessionID, SSMPRUint32 version, 
-			      SSMPRUint32 httpPort, SSMPRUint32 nonceLen, 
-			      char * nonce, SSMPolicyType policy);
-
-/* Parse data connections requests */
-SSMPRStatus SSM_ParseSSLDataConnectionRequest(void *sslRequest, 
-					      SSMPRUint32 * flags, 
-					      SSMPRUint32 * port,
-					      SSMPRUint32 * hostIPLen,
-					      char ** hostIP, 
-					      SSMPRUint32 * hostNameLen,
-					      char ** hostName);
-SSMPRStatus SSM_ParseHashStreamRequest(void * hashStreamRequest,
-                                       SSMPRUint32 * type);
-SSMPRStatus SSM_ParseP7EncodeConnectionRequest(void *request,
-					       SSMPRUint32 *ciRID);
-/* Messages to initiate PKCS7 data connection */
-/* PKCS7DecodeRequest message has no data */ 
-
-/* Single data connection reply */
-SSMPRInt32 SSM_PackDataConnectionReply(void ** sslReply, 
-				       SSMPRInt32 result, 
-				       SSMPRUint32 connID, 
-				       SSMPRUint32 port);
-
-SSMPRStatus SSM_ParseSSLSocketStatusRequest(void * statusRequest, 
-					    SSMPRUint32 * connID);
-SSMPRInt32 SSM_PackSSLSocketStatusReply(void ** statusReply, 
-					SSMPRInt32 result, 
-					SSMPRUint32 resourceID);
-
-/* 
- * UI event is an asynchroneous message sent from PSM server to the client
- * NOTE: (context) is the actual context pointer, it is NOT a ptr-to-ptr.
- * The value of (context) is copied into the packet.
- */
-SSMPRInt32 SSM_PackUIEvent(void ** eventRequest, SSMPRUint32 resourceID, 
-			   SSMPRUint32 width, SSMPRUint32 height,
-			   SSMPRUint32 urlLen, char * url);
-
-SSMPRInt32 SSM_PackTaskCompletedEvent(void **event, SSMPRUint32 resourceID,
-                                     SSMPRUint32 numTasks, SSMPRUint32 result);
-
-/* Verify raw signature */
-
-SSMPRStatus SSM_ParseVerifyRawSigRequest(void * verifyRawSigRequest, 
-					 SSMPRUint32 * algorithmID,
-					 SSMPRUint32 * paramsLen, 
-					 unsigned char ** params,
-					 SSMPRUint32 * pubKeyLen,
-					 unsigned char ** pubKey,
-					 SSMPRUint32 * hashLen,
-					 unsigned char ** hash,
-					 SSMPRUint32 * signatureLen,
-					 unsigned char ** signature);
-SSMPRInt32 SSM_PackVerifyRawSigReply(void ** verifyRawSigReply, 
-				     SSMPRInt32 result);
-
-/* Verify detached signature */
-SSMPRStatus SSM_ParseVerifyDetachedSigRequest(void * request, 
-											  SSMPRInt32 * pkcs7ContentID,
-											  SSMPRInt32 * certUsage,
-											  SSMPRInt32 * hashAlgID,
-											  SSMPRUint32 * keepCert,
-											  SSMPRUint32 * digestLen,
-											  unsigned char ** hash);
-
-SSMPRInt32 SSM_PackVerifyDetachedSigReply(void ** verifyDetachedSigReply, 
-										  SSMPRInt32 result);
-
-/* PKCS#7 functions */
-SSMPRStatus SSM_ParseCreateSignedRequest(void *request,
-                                         SSMPRInt32 *scertRID,
-                                         SSMPRInt32 *ecertRID,
-                                         SSMPRUint32 *dig_alg,
-                                         SECItem **digest);
-
-SSMPRInt32 SSM_PackCreateSignedReply(void **reply, SSMPRInt32 ciRID,
-                                     SSMPRUint32 result);
-
-SSMPRStatus SSM_ParseCreateEncryptedRequest(void *request,
-					    SSMPRInt32 *scertRID,
-                                            SSMPRInt32 *nrcerts,
-					    SSMPRInt32 **rcertRIDs);
-
-SSMPRInt32 SSM_PackCreateEncryptedReply(void **reply, SSMPRInt32 ciRID,
-					SSMPRUint32 result);
-
-/* Resource functions */
-SSMPRStatus SSM_ParseCreateResourceRequest(void *request,
-                                           SSMPRUint32 *type,
-                                           unsigned char **params,
-                                           SSMPRUint32 *paramLen);
-
-SSMPRStatus SSM_PackCreateResourceReply(void **reply, SSMPRStatus rv,
-                                        SSMPRUint32 resID);
-
-SSMPRStatus SSM_ParseGetAttribRequest(void * getAttribRequest, 
-				      SSMPRUint32 * resourceID, 
-				      SSMPRUint32 * fieldID);
-
-void SSM_DestroyAttrValue(SSMAttributeValue *value, PRBool freeit);
-
-SSMPRInt32 SSM_PackGetAttribReply(void **getAttribReply,
-				  SSMPRInt32 result,
-				  SSMAttributeValue *value);
-SSMPRStatus SSM_ParseSetAttribRequest(SECItem *msg,
-				      SSMPRInt32 *resourceID,
-				      SSMPRInt32 *fieldID,
-				      SSMAttributeValue *value);
-/* Currently, there is no need for a pack version.  There is nothing to send
- * back except for the notice that the operation was successful.
- */
-				  
-				       
-				       
-/* Pickle and unpickle resources. */
-SSMPRStatus SSM_ParsePickleResourceRequest(void * pickleResourceRequest, 
-					  SSMPRUint32 * resourceID);
-SSMPRInt32 SSM_PackPickleResourceReply(void ** pickleResourceReply, 
-				       SSMPRInt32 result,
-				       SSMPRUint32 resourceLen,
-				       void * resource);
-SSMPRStatus SSM_ParseUnpickleResourceRequest(void * unpickleResourceRequest,
-					     SSMPRUint32 blobSize,
-					     SSMPRUint32 * resourceType,
-					     SSMPRUint32 * resourceLen,
-					     void ** resource);
-SSMPRInt32 SSM_PackUnpickleResourceReply(void ** unpickleResourceReply, 
-					   SSMPRInt32 result, 
-					   SSMPRUint32 resourceID);
-
-/* Destroy resource */
-SSMPRStatus SSM_ParseDestroyResourceRequest(void * destroyResourceRequest, 
-					    SSMPRUint32 * resourceID, 
-					    SSMPRUint32 * resourceType);
-SSMPRInt32 SSM_PackDestroyResourceReply(void ** destroyResourceReply, 
-                                        SSMPRInt32 result);
-
-/* Duplicate resource */
-SSMPRStatus SSM_ParseDuplicateResourceRequest(void * request, 
-					      SSMPRUint32 * resourceID);
-SSMPRInt32 SSM_PackDuplicateResourceReply(void ** reply, SSMPRInt32 result,
-					  SSMPRUint32 resID);
-
-/* Cert actions */
-typedef struct MatchUserCertRequestData {
-    PRUint32 certType;
-    PRInt32 numCANames;
-    char ** caNames;
-} MatchUserCertRequestData;
-
-typedef struct SSMCertList {
-    PRCList certs;
-    PRInt32 count;
-} SSMCertList;
-
-typedef struct SSMCertListElement {
-    PRCList links;
-    PRUint32 certResID;
-} SSMCertListElement;
-
-#define SSM_CERT_LIST_ELEMENT_PTR(_q) (SSMCertListElement*)(_q);
-
-SSMPRStatus SSM_ParseVerifyCertRequest(void * verifyCertRequest, 
-				       SSMPRUint32 * resourceID, 
-				       SSMPRInt32 * certUsage);
-SSMPRInt32 SSM_PackVerifyCertReply(void ** verifyCertReply, 
-			           SSMPRInt32 result);
-
-SSMPRStatus SSM_ParseImportCertRequest(void * importCertRequest, 
-				       SSMPRUint32 * blobLen, 
-				       void ** certBlob);
-SSMPRInt32 SSM_PackImportCertReply(void ** importCertReply, SSMPRInt32 result, 
-				   SSMPRUint32 resourceID);
-PRStatus SSM_ParseFindCertByNicknameRequest(void *request, char ** nickname);
-PRInt32 SSM_PackFindCertByNicknameReply(void ** reply, PRUint32 resourceID);
-PRStatus SSM_ParseFindCertByKeyRequest(void *request, SECItem ** key);
-PRInt32 SSM_PackFindCertByKeyReply(void ** reply, PRUint32 resourceID);
-PRStatus SSM_ParseFindCertByEmailAddrRequest(void *request, char ** emailAddr);
-PRInt32 SSM_PackFindCertByEmailAddrReply(void ** reply, PRUint32 resourceID);
-PRStatus SSM_ParseAddTempCertToDBRequest(void *request, PRUint32 *resourceID, char ** nickname, PRInt32 *ssl, PRInt32 *email, PRInt32 *objectSigning);
-PRInt32 SSM_PackAddTempCertToDBReply(void ** reply);
-PRStatus SSM_ParseMatchUserCertRequest(void *request, MatchUserCertRequestData** data);
-PRInt32 SSM_PackMatchUserCertReply(void **reply, SSMCertList * certList);
-
-SSMPRInt32 SSM_PackErrorMessage(void ** errorReply, SSMPRInt32 result);
-
-
-/* PKCS11 actions */
-SSMPRStatus SSM_ParseKeyPairGenRequest(void *keyPairGenRequest, 
-				       SSMPRInt32 requestLen,
-				       SSMPRUint32 *keyPairCtxtID,
-				       SSMPRUint32 *genMechanism,
-				       SSMPRUint32 *keySize,
-				       unsigned char **params, 
-				       SSMPRUint32 *paramLen);
-
-SSMPRInt32 SSM_PackKeyPairGenResponse(void ** keyPairGenResponse, 
-				      SSMPRUint32 keyPairId);
-
-PRStatus
-SSM_ParseFinishKeyGenRequest(void    *finishKeyGenRequest,
-                             PRInt32  requestLen,
-                             PRInt32 *keyGenContext);
-
-/* CMMF/CRMF Actions */
-SSMPRStatus SSM_ParseCreateCRMFReqRequest(void        *crmfReqRequest,
-					  SSMPRInt32   requestLen,
-					  SSMPRUint32 *keyPairId);
-
-SSMPRInt32 SSM_PackCreateCRMFReqReply(void        **crmfReqReply,
-				      SSMPRUint32   crmfReqId);
-
-SSMPRStatus SSM_ParseEncodeCRMFReqRequest(void         *encodeReq,
-					  SSMPRInt32    requestLen,
-					  SSMPRUint32 **crmfReqId,
-					  SSMPRInt32   *numRequests);
-
-SSMPRInt32 SSM_PackEncodeCRMFReqReply(void        **encodeReply,
-				      char         *crmfDER,
-				      SSMPRUint32   derLen);
-
-SSMPRStatus SSM_ParseCMMFCertResponse(void        *encodedRes,
-				      SSMPRInt32   encodeLen,
-				      char       **nickname,
-				      char       **base64Der,
-				      PRBool      *doBackup);
-
-PRStatus SSM_ParsePOPChallengeRequest(void     *challenge,
-				      PRInt32   len,
-				      char    **responseString);
-PRInt32 SSM_PackPOPChallengeResponse(void   **response,
-				     char    *responseString,
-				     PRInt32  responseStringLen);
-
-PRInt32 SSM_PackPasswdRequest(void ** passwdRequest, PRInt32 tokenID,
-                              char * prompt, PRInt32 promptLen);
-PRStatus SSM_ParsePasswordReply(void * passwdReply, PRInt32 * result, 
-                                PRInt32 * tokenID,
-                                char ** passwd, PRInt32 * passwdLen);
-
-/* Sign Text Actions */
-typedef struct {
-    char *stringToSign;
-    char *hostName;
-    char *caOption;
-    PRInt32 numCAs;
-    char **caNames;
-} signTextRequestData;
-
-PRStatus SSM_ParseSignTextRequest(void* signTextRequest, PRInt32 len, PRUint32* resID, signTextRequestData ** data);
-
-PRStatus SSM_ParseGetLocalizedTextRequest(void               *data,
-                                          SSMLocalizedString *whichString);  
-
-PRInt32 SSM_PackGetLocalizedTextResponse(void               **data,
-					 SSMLocalizedString   whichString,
-					 char                *retString);
-
-PRStatus SSM_ParseAddNewSecurityModuleRequest(void          *data, 
-					      char         **moduleName,
-					      char         **libraryPath, 
-					      unsigned long *pubMechFlags,
-					      unsigned long *pubCipherFlags);
-
-PRInt32 SSM_PackAddNewModuleResponse(void **data, PRInt32 rv);
-
-PRStatus SSM_ParseDeleteSecurityModuleRequest(void *data, char **moduleName);
-
-PRInt32 SSM_PackDeleteModuleResponse(void **data, PRInt32 moduleType);
-
-PRInt32 SSM_PackFilePathRequest(void **data, PRInt32 resID, char *prompt,
-				PRBool shouldFileExist, char *fileSuffix);
-
-PRStatus SSM_ParseFilePathReply(void *message, char **filePath,
-				PRInt32 *rid);
-
-PRInt32 SSM_PackPromptRequestEvent(void **data, PRInt32 resID, char *prompt);
-PRStatus SSM_ParsePasswordPromptReply(void *data, PRInt32 *resID, 
-				      char **reply);
-
-/* messages for importing certs *the traditional way* */
-PRInt32 SSM_PackDecodeCertReply(void ** data, PRInt32 certID);
-PRStatus SSM_ParseDecodeCertRequest(void * data, PRInt32 * len, 
-					char ** buffer);
-PRStatus SSM_ParseGetKeyChoiceListRequest(void * data, PRUint32 dataLen, 
-					  char ** type, PRUint32 *typeLen, 
-					  char ** pqgString, PRUint32 *pqgLen);
-PRInt32 SSM_PackGetKeyChoiceListReply(void **data, char ** list);
-
-PRStatus SSM_ParseGenKeyOldStyleRequest(void * data, PRUint32 datalen, 
-					char ** choiceString, 
-					char ** challenge, 
-					char ** typeString, 
-					char ** pqgString);
-PRInt32 SSM_PackGenKeyOldStyleReply(void ** data, char * keydata);
-
-PRStatus SSM_ParseDecodeAndCreateTempCertRequest(void * data, 
-			char ** certbuf, PRUint32 * certlen, int * certClass);
-
-#endif /*PROTOCOLF_H_*/

mozilla/security/psm/lib/protocol/protocolnspr20.h

@@ -1,74 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-/*****************************************************************************
- *
- *
- *
- *****************************************************************************
- */
-
-#ifndef NULL
-#define NULL 0x00000000
-#endif
-
-#define SSMPR_BYTES_PER_INT  4
-#define SSMPR_BYTES_PER_LONG  4
-
-/******************************************************************
- *  No NSPR - define all the SSMPR values and functions here   
- ******************************************************************
- */
-
-#define SSMPRStatus PRStatus
-#define SSMPR_SUCCESS PR_SUCCESS
-#define SSMPR_FAILURE PR_FAILURE
-
-#define SSMPR_INVALID_ARGUMENT_ERROR PR_INVALID_ARGUMENT_ERROR
-#define SSMPR_OUT_OF_MEMORY_ERROR    PR_OUT_OF_MEMORY_ERROR
-
-#define SSMPRInt32 PRInt32
-#define SSMPRUint32 PRUint32
-
-#define SSMPR_ntohl  PR_ntohl
-#define SSMPR_htonl  PR_htonl
-#define SSMPORT_Free   PORT_Free
-#define SSMPORT_ZAlloc PORT_ZAlloc
-
-#define SSMPR_SetError PR_SetError
-#define SSMPR_GetError PR_GetError
-#define SSMPORT_SetError PORT_SetError
-#define SSMPORT_GetError PORT_GetError
-
-
-
-

mozilla/security/psm/lib/protocol/protocolport.c

@@ -1,49 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-/*************************************************************************
- *
- * PSM portable run-time. (Used when NSPR20 is not available.)
- *
- *************************************************************************
- */
-
-SSMPRInt32 ssmprErrno;
-
-void SSMPORT_SetError(SSMPRInt32 errorcode) 
-{ ssmprErrno = errorcode; }  
-
-
-SSMPRInt32 SSMPORT_GetError(void)
-{ return ssmprErrno; }
-
-

mozilla/security/psm/lib/protocol/protocolport.h

@@ -1,93 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-/*****************************************************************************
- *
- *
- *
- *****************************************************************************
- */
-
-#ifndef NULL
-#define NULL 0x00000000
-#endif
-
-#define SSMPR_BYTES_PER_INT  4
-#define SSMPR_BYTES_PER_LONG  4
-
-/******************************************************************
- *  No NSPR - define all the SSMPR values and functions here   
- ******************************************************************
- */
-
-typedef enum { SSMPR_SUCCESS = 0,  SSMPR_FAILURE = -1 } SSMPRStatus;
-enum { 
-  SSMPR_INVALID_ARGUMENT_ERROR = -6000,
-  SSMPR_OUT_OF_MEMORY_ERROR =  -5987
-};
-
-#if SSMPR_BYTES_PER_INT == 4
-typedef unsigned int SSMPRUint32;
-typedef int SSMPRInt32; 
-#elif SSMPR_BYTES_PER_LONG == 4
-typedef unsigned long SSMPRUint32;
-typedef long SSMPRInt32;
-#else
-#error No suitable type for SSMPRInt32/SSMPRUint32
-#endif
-
-/*******************************************************************
- * Use libc functions instead 
- *******************************************************************
- */
-#include <sys/types.h>
-#ifdef WIN32
-#include <winsock.h>
-#else
-#include <netinet/in.h>
-#endif
-#define SSMPR_ntohl  ntohl
-#define SSMPR_htonl  htonl
-
-#include <stdlib.h>
-#define SSMPORT_Free   free
-#define SSMPR_sprint   printf
-#define SSMPORT_ZAlloc malloc
-
-extern SSMPRInt32 ssmprErrno;
-#define SSMPR_SetError(x, y) SSMPORT_SetError(x)
-#define SSMPR_GetError SSMPORT_GetError
-void SSMPORT_SetError(SSMPRInt32 errorcode);
-
-
-
-