removed the report of db filesize in GetStorageInUse.

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

mozilla/netwerk/cache/Makefile.in

@@ -19,14 +19,20 @@
 # Contributor(s): 
 #
 
-DEPTH		= ../../..
+DEPTH		= ../..
 topsrcdir	= @top_srcdir@
 srcdir		= @srcdir@
 VPATH		= @srcdir@
 
 include $(DEPTH)/config/autoconf.mk
 
-DIRS		= protocol client nlslayer
+DIRS		= \
+        public \
+        memcache \
+        filecache \
+        mgr \
+        build \
+		$(NULL)
 
 include $(topsrcdir)/config/rules.mk
 

mozilla/netwerk/cache/Makefile.win

@@ -1,4 +1,4 @@
-#!nmake
+#!gmake
 #
 # The contents of this file are subject to the Netscape Public
 # License Version 1.1 (the "License"); you may not use this file
@@ -19,9 +19,15 @@
 #
 # Contributor(s): 
 
-DEPTH=..\..\..
-include <$(DEPTH)/config/config.mak>
 
-DIRS = client protocol
+DEPTH=..\..
+DIRS= 	\
+	public                  \
+	mgr			\
+	memcache		\
+	filecache		\
+	build                   \
+	$(NULL)
 
 include <$(DEPTH)\config\rules.mak>
+

mozilla/netwerk/cache/build/Makefile.in

@@ -0,0 +1,54 @@
+#
+# 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		= nkcacke
+LIBRARY_NAME	= necko_cache
+IS_COMPONENT	= 1
+
+CPPSRCS		= nsNetDataCacheModule.cpp
+
+SHARED_LIBRARY_LIBS = \
+		$(DIST)/lib/libnkcachemgr_s.a \
+		$(DIST)/lib/libnkfilecache_s.a \
+		$(DIST)/lib/libnkmemcache_s.a \
+        $(DIST)/lib/libmozdbm_s.a     \
+        $(DIST)/lib/libxpcomio_s.a \
+		$(NULL)
+
+LOCAL_INCLUDES	= \
+		-I$(DEPTH)/netwerk/cache/memcache \
+		-I$(DEPTH)/netwerk/cache/filecache \
+		-I$(DEPTH)/netwerk/cache/mgr \
+		$(NULL)
+
+EXTRA_DSO_LDOPTS = \
+		$(MKSHLIB_FORCE_ALL) \
+		$(SHARED_LIBRARY_LIBS) \
+		$(MKSHLIB_UNFORCE_ALL) \
+		$(NULL)
+
+include $(topsrcdir)/config/rules.mk
+
+$(LIBRARY) $(SHARED_LIBRARY): $(SHARED_LIBRARY_LIBS) Makefile
+

mozilla/netwerk/cache/build/makefile.win

@@ -0,0 +1,51 @@
+#!gmake
+#
+# 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.
+#
+
+DEPTH=..\..\..
+MODULE=nkcache
+
+MAKE_OBJ_TYPE=DLL
+DLLNAME=nkcache
+DLL=.\$(OBJDIR)\$(DLLNAME).dll
+
+CPP_OBJS=                                    \
+        .\$(OBJDIR)\nsNetDataCacheModule.obj \
+	$(NULL)
+
+LLIBS=                                \
+        $(DIST)\lib\nkcachemgr_s.lib  \
+        $(DIST)\lib\nkfilecache_s.lib \
+        $(DIST)\lib\nkmemcache_s.lib  \
+        $(DIST)\lib\dbm32.lib         \
+        $(DIST)\lib\xpcom.lib         \
+        $(LIBNSPR)  
+
+INCS = $(INCS)                             \
+        -I$(DEPTH)\netwerk\cache\memcache  \
+        -I$(DEPTH)\netwerk\cache\filecache \
+        -I$(DEPTH)\netwerk\cache\mgr       \
+        $(NULL)
+
+include <$(DEPTH)\config\rules.mak>
+
+install:: $(DLL)
+	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).dll $(DIST)\bin\components
+	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).lib $(DIST)\lib
+

mozilla/netwerk/cache/build/nsNetDataCacheModule.cpp

@@ -0,0 +1,49 @@
+ /* -*- 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.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 Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ */
+
+#include "nsCOMPtr.h"
+#include "nsIModule.h"
+#include "nscore.h"
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+#include "nsIGenericFactory.h"
+
+#include "nsINetDataCache.h"
+#include "nsINetDataCacheManager.h"
+#include "nsMemCacheCID.h"
+#include "nsMemCache.h"
+#include "nsNetDiskCache.h"
+#include "nsNetDiskCacheCID.h"
+#include "nsCacheManager.h"
+
+// Factory method to create a new nsMemCache instance.  Used
+// by nsNetDataCacheModule
+NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsMemCache, Init)
+NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsNetDiskCache, Init)
+NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsCacheManager, Init)
+
+static nsModuleComponentInfo components[] = {
+    { "Memory Cache", NS_MEM_CACHE_FACTORY_CID, NS_NETWORK_MEMORY_CACHE_PROGID, nsMemCacheConstructor },
+    { "File Cache",   NS_NETDISKCACHE_CID,      NS_NETWORK_FILE_CACHE_PROGID,   nsNetDiskCacheConstructor },
+    { "Cache Manager",NS_CACHE_MANAGER_CID,     NS_NETWORK_CACHE_MANAGER_PROGID,nsCacheManagerConstructor }
+};
+
+NS_IMPL_NSGETMODULE("Network Data Cache", components)

mozilla/netwerk/cache/filecache/Makefile.in

@@ -0,0 +1,60 @@
+# 
+# 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 Mozilla Communicator.
+# 
+# The Initial Developer of the Original Code is Intel Corp.
+# Portions created by Intel Corp. are
+# Copyright (C) 1999, 1999 Intel Corp.  All
+# Rights Reserved.
+# 
+# Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+#                 Carl Wong <carl.wong@intel.com>
+# 
+
+DEPTH		= ../../..
+topsrcdir	= @top_srcdir@
+VPATH       = @srcdir@
+srcdir		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE = nkcache
+
+LIBRARY_NAME = nkfilecache_s
+
+REQUIRES	= nspr dbm 
+
+EXTRA_DSO_LDOPTS  +=  -L$(DIST)/lib  -lmozdbm_s
+
+EXPORTS=nsNetDiskCacheCID.h \
+	nsNetDiskCache.h \
+	nsIDBAccessor.h \
+	nsDBAccessor.h \
+	$(NULL)
+
+CPPSRCS		= \
+        nsDBAccessor.cpp\
+        nsDBEnumerator.cpp \
+        nsNetDiskCache.cpp \
+        nsDiskCacheRecord.cpp \
+        nsDiskCacheRecordChannel.cpp \
+		$(NULL)
+
+EXTRA_LIBS	= $(NSPR_LIBS) 
+
+# we don't want the shared lib, but we want to force the creation of a
+# static lib.
+override NO_SHARED_LIB=1
+override NO_STATIC_LIB=
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/netwerk/cache/filecache/makefile.win

@@ -0,0 +1,44 @@
+#!gmake
+#
+# 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=..\..\..
+
+include <$(DEPTH)/config/config.mak>
+
+MODULE = nkcache
+
+LIBRARY_NAME = nkfilecache_s
+
+CPP_OBJS=                                    \
+        .\$(OBJDIR)\nsDBAccessor.obj         \
+        .\$(OBJDIR)\nsDBEnumerator.obj       \
+        .\$(OBJDIR)\nsNetDiskCache.obj       \
+        .\$(OBJDIR)\nsDiskCacheRecord.obj    \
+        .\$(OBJDIR)\nsDiskCacheRecordChannel.obj    \
+	$(NULL)
+
+EXPORTS=nsNetDiskCacheCID.h
+
+include <$(DEPTH)\config\rules.mak> 
+
+install:: $(LIBRARY)
+	$(MAKE_INSTALL) $(LIBRARY) $(DIST)\lib
+
+clobber::
+        rm -rf $(OBJDIR)
+        rm -f $(DIST)\lib\$(LIBRARY_NAME).lib
+

mozilla/netwerk/cache/filecache/nsDBAccessor.cpp

@@ -0,0 +1,416 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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 Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+/*
+ * This file is part of filecache implementation.
+ * 
+ * nsIDBAccessor is a interface that shields all the direct database access 
+ * method from nsNetDiskCache. 
+ * 
+ * nsDBAccessor is a implementation of the nsIDBAccessor interface. It
+ * uses dbm(Berkely) as the database. 
+ * 
+ * a nsDiskCacheRecord is mapped into two entries in the database, 
+ *    key->recordID
+ *    recordID->metadata
+ */
+
+#include "nsDBAccessor.h"
+#include "nscore.h"
+
+#include "prtypes.h"
+#include "plhash.h"
+#include "nsCRT.h"
+
+nsDBAccessor::nsDBAccessor() :
+  mDB(0) ,
+  mDBFile(0) ,
+  mSessionID(0) ,
+  mSessionCntr(0) ,
+  mDBFilesize(0) 
+{
+  mLastSyncTime = PR_IntervalNow() ;
+
+  NS_INIT_REFCNT();
+}
+
+nsDBAccessor::~nsDBAccessor()
+{
+  Shutdown() ;
+}
+
+//
+// Implement nsISupports methods
+//
+NS_IMPL_ISUPPORTS(nsDBAccessor, NS_GET_IID(nsIDBAccessor))
+
+
+///////////////////////////////////////////////////////////
+// nsIDBAccessor methods 
+
+NS_IMETHODIMP
+nsDBAccessor::Init(nsIFileSpec* dbfile)
+{
+  char* dbname ;
+
+  // this should cover all platforms. 
+  dbfile->GetNativePath(&dbname) ;
+  
+  mDBFile = dbfile ;
+
+  // FUR - how is page size chosen ?  It's worth putting a comment
+  // in here about the possible usefulness of tuning these parameters
+  HASHINFO hash_info = {
+    16*1024 , /* bucket size */
+    0 ,       /* fill factor */
+    0 ,       /* number of elements */
+    0 ,       /* bytes to cache */
+    0 ,       /* hash function */
+    0} ;      /* byte order */
+
+  mDB = dbopen(dbname,
+               O_RDWR | O_CREAT ,
+               0600 ,
+               DB_HASH ,
+               & hash_info) ;
+
+  nsCRT::free(dbname) ;
+
+  if(!mDB)
+    return NS_ERROR_FAILURE ;
+
+  // set mSessionID
+  DBT db_key, db_data ;
+
+  db_key.data = NS_CONST_CAST(char*, SessionKey) ;
+  db_key.size = PL_strlen(SessionKey) ;
+
+  int status = (*mDB->get)(mDB, &db_key, &db_data, 0) ;
+  if(status == -1) {
+    NS_ERROR("ERROR: failed get session id in database.") ;
+    return NS_ERROR_FAILURE ;
+  }
+
+  if(status == 0) {
+    // get the last session id
+    PRInt16 *old_ID = NS_STATIC_CAST(PRInt16*, db_data.data) ;
+    if(*old_ID < ini_sessionID) {
+      NS_ERROR("ERROR: Bad Session ID in database, corrupted db.") ;
+      return NS_ERROR_FAILURE ;
+    }
+
+    mSessionID = *old_ID + 1 ;
+  } 
+  else if(status == 1) {
+    // must be a new db
+    mSessionID = ini_sessionID ;
+  }
+  db_data.data = NS_REINTERPRET_CAST(void*, &mSessionID) ;
+  db_data.size = sizeof(PRInt16) ;
+
+  // store the new session id
+  status = (*mDB->put)(mDB, &db_key, &db_data, 0) ;
+
+  if(status == 0) {
+    (*mDB->sync)(mDB, 0) ;
+
+    // initialize database filesize
+    return mDBFile->GetFileSize(&mDBFilesize) ;
+  } 
+  else {
+    NS_ERROR("reset session ID failure.") ;
+    return NS_ERROR_FAILURE ;
+  }
+  
+}
+
+NS_IMETHODIMP
+nsDBAccessor::Shutdown(void)
+{
+  if(mDB) {
+    (*mDB->sync)(mDB, 0) ;
+    (*mDB->close)(mDB) ;
+    mDB = nsnull ;
+  }
+
+  return NS_OK ;
+}
+  
+NS_IMETHODIMP
+nsDBAccessor::Get(PRInt32 aID, void** anEntry, PRUint32 *aLength) 
+{
+  if(!anEntry)
+    return NS_ERROR_NULL_POINTER ;
+
+  *anEntry = nsnull ;
+  *aLength = 0 ;
+
+  NS_ASSERTION(mDB, "no database") ;
+
+  DBT db_key, db_data ;
+
+  db_key.data = NS_REINTERPRET_CAST(void*, &aID) ;
+  db_key.size = sizeof(PRInt32) ;
+  
+  int status = 0 ;
+  status = (*mDB->get)(mDB, &db_key, &db_data, 0) ;
+
+  if(status == 0) {
+    *anEntry = db_data.data ;
+    *aLength = db_data.size ;
+    return NS_OK ;
+  } 
+  else if(status == 1)
+    return NS_OK ;
+  else
+    return NS_ERROR_FAILURE ;
+
+}
+
+NS_IMETHODIMP
+nsDBAccessor::Put(PRInt32 aID, void* anEntry, PRUint32 aLength)
+{
+  NS_ASSERTION(mDB, "no database") ;
+
+  DBT db_key, db_data ;
+
+  db_key.data = NS_REINTERPRET_CAST(void*, &aID) ;
+  db_key.size = sizeof(PRInt32) ;
+
+  db_data.data = anEntry ;
+  db_data.size = aLength ;
+
+  if(0 == (*mDB->put)(mDB, &db_key, &db_data, 0)) {
+    return Sync() ;
+  }
+  else {
+    return NS_ERROR_FAILURE ;
+  }
+}
+
+/*
+ * It's more important to remove the id->metadata entry first since
+ * key->id mapping is just a reference
+ */
+NS_IMETHODIMP
+nsDBAccessor::Del(PRInt32 aID, void* anEntry, PRUint32 aLength)
+{
+  NS_ASSERTION(mDB, "no database") ;
+
+  DBT db_key ;
+
+  // delete recordID->metadata
+  db_key.data = NS_REINTERPRET_CAST(void*, &aID) ;
+  db_key.size = sizeof(PRInt32) ;
+
+  PRInt32 status = -1 ;
+  status = (*mDB->del)(mDB, &db_key, 0) ;
+
+  if(-1 == status) {
+    return NS_ERROR_FAILURE ;
+  } 
+
+  // delete key->recordID
+  db_key.data = anEntry ;
+  db_key.size = aLength ;
+  status = (*mDB->del)(mDB, &db_key, 0) ;
+  if(-1 == status) {
+    return NS_ERROR_FAILURE ;
+  } 
+
+  return Sync() ;
+}
+
+NS_IMETHODIMP
+nsDBAccessor::GetID(const char* key, PRUint32 length, PRInt32* aID) 
+{
+  NS_ASSERTION(mDB, "no database") ;
+
+  DBT db_key, db_data ;
+
+  db_key.data = NS_CONST_CAST(char*, key) ;
+  db_key.size = length ;
+
+  int status = (*mDB->get)(mDB, &db_key, &db_data, 0) ;
+  if(status == 0) {
+    // found recordID
+    *aID = *(NS_REINTERPRET_CAST(PRInt32*, db_data.data)) ;
+    return NS_OK ;
+  }
+  else if(status == 1) {
+    // create a new one
+    PRInt32 id = 0 ;
+    id = mSessionID << 16 | mSessionCntr++ ;
+
+    // add new id into mDB
+    db_data.data = NS_REINTERPRET_CAST(void*, &id) ;
+    db_data.size = sizeof(PRInt32) ;
+
+    status = (*mDB->put)(mDB, &db_key, &db_data, 0) ;
+    if(status != 0) {
+      NS_ERROR("updating db failure.") ;
+      return NS_ERROR_FAILURE ;
+    }
+    *aID = id ;
+    return Sync() ;
+  } 
+  else {
+    NS_ERROR("ERROR: keydb failure.") ;
+    return NS_ERROR_FAILURE ;
+  }
+}
+
+NS_IMETHODIMP
+nsDBAccessor::EnumEntry(void** anEntry, PRUint32* aLength, PRBool bReset) 
+{
+  if(!anEntry)
+    return NS_ERROR_NULL_POINTER ;
+
+  *anEntry = nsnull ;
+  *aLength = 0 ;
+
+  NS_ASSERTION(mDB, "no database") ;
+
+  PRUint32 flag ;
+
+  if(bReset) 
+    flag = R_FIRST ;
+  else
+    flag = R_NEXT ;
+
+  DBT db_key, db_data ;
+
+  PRUint32 len = PL_strlen(SessionKey) ;
+
+  int status ;
+
+  do {
+    status = (*mDB->seq)(mDB, &db_key, &db_data, flag) ;
+    flag = R_NEXT ;
+    if(status == -1)
+      return NS_ERROR_FAILURE ;
+    // get next if it's a key->recordID 
+    if(db_key.size > sizeof(PRInt32) && db_data.size == sizeof(PRInt32))
+      continue ;
+    // get next if it's a sessionID entry
+    if(db_key.size == len && db_data.size == sizeof(PRInt16))
+      continue ;
+    // recordID is always 32 bits long
+    if(db_key.size == sizeof(PRInt32))
+      break ;
+  } while(!status) ;
+
+  if (0 == status) {
+    *anEntry = db_data.data ;
+    *aLength = db_data.size ;
+  }
+  return NS_OK ;
+}
+
+/*
+ * returns the cached database file size.
+ * mDBFilesize will be updated during Sync().
+ */
+NS_IMETHODIMP
+nsDBAccessor::GetDBFilesize(PRUint32* aSize)
+{
+  *aSize = mDBFilesize ;
+  return NS_OK ; 
+}
+
+NS_IMETHODIMP
+nsDBAccessor::GetSpecialEntry(void** anEntry, PRUint32* aLength)
+{
+  if(!anEntry)
+    return NS_ERROR_NULL_POINTER ;
+
+  *anEntry = nsnull ;
+  *aLength = 0 ;
+
+  DBT db_key, db_data ;
+
+  db_key.data = NS_CONST_CAST(char*, SpecialEntry) ;
+  db_key.size = PL_strlen(SpecialEntry) ;
+
+  int status = (*mDB->get)(mDB, &db_key, &db_data, 0) ;
+
+  if(status == -1) {
+    NS_ERROR("ERROR: failed get special entry in database.") ;
+    return NS_ERROR_FAILURE ;
+  }
+
+  if(status == 0) {
+    *anEntry = db_data.data ;
+    *aLength = db_data.size ;
+  } 
+  
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsDBAccessor::SetSpecialEntry(void* anEntry, PRUint32 aLength)
+{
+  DBT db_key, db_data ;
+
+  db_key.data = NS_CONST_CAST(char*, SpecialEntry) ;
+  db_key.size = PL_strlen(SpecialEntry) ;
+
+  db_data.data = anEntry ;
+  db_data.size = aLength ;
+
+  if(0 == (*mDB->put)(mDB, &db_key, &db_data, 0)) {
+    (*mDB->sync)(mDB, 0) ;
+    return NS_OK ;
+  }
+  else {
+    return NS_ERROR_FAILURE ;
+  }
+}
+
+/*
+ * sync routine is only called when the SyncInterval is reached. Otherwise
+ * it just returns. If db synced, the filesize will be updated at the
+ * same time.
+ */
+nsresult
+nsDBAccessor::Sync(void)
+{
+  PRIntervalTime time = PR_IntervalNow() ;
+  PRIntervalTime duration = time - mLastSyncTime ;
+  
+  if (PR_IntervalToMilliseconds(duration) > SyncInterval) {
+    int status = (*mDB->sync)(mDB, 0) ;
+    if(status == 0) {
+//      printf("\tsynced\n") ;
+      mLastSyncTime = time ;
+      
+      // update db filesize here
+      return mDBFile->GetFileSize(&mDBFilesize) ;
+      
+    } else
+      return NS_ERROR_FAILURE ;
+  } else {
+//    printf("\tnot synced\n") ;
+    return NS_OK ;
+  }
+}

mozilla/netwerk/cache/filecache/nsDBAccessor.h

@@ -0,0 +1,93 @@
+/*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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 Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+/*
+ * This file is part of filecache implementation.
+ * 
+ * nsIDBAccessor is a interface that shields all the direct database access 
+ * method from nsNetDiskCache. 
+ * 
+ * nsDBAccessor is a implementation of the nsIDBAccessor interface. It
+ * uses dbm(Berkely) as the database. 
+ *
+ */
+
+#ifndef _NSIDBACCESSOR_H_
+#define _NSIDBACCESSOR_H_
+
+#include "nsIDBAccessor.h"
+#include "mcom_db.h"
+#include "prinrval.h"
+#include "nsCOMPtr.h"
+
+// bogus string for the key of session id 
+static const char * const SessionKey = "SK" ;
+
+// bogus string for the size 
+static const char * const SpecialEntry = "SE" ;
+
+// initial session id number 
+static const PRInt16 ini_sessionID = 0xff ;
+
+static const PRUint16 SyncInterval = 1000 ;
+
+class nsDBAccessor : public nsIDBAccessor
+{
+  public:
+  NS_DECL_ISUPPORTS
+
+  nsDBAccessor() ;
+  virtual ~nsDBAccessor() ;
+  
+  NS_IMETHOD Init(nsIFileSpec* dbfile) ;
+  NS_IMETHOD Shutdown(void) ; 
+
+  NS_IMETHOD Put(PRInt32 aID, void* anEntry, PRUint32 aLength) ;
+
+  NS_IMETHOD Get(PRInt32 aID, void** anEntry, PRUint32 *aLength) ;
+
+  NS_IMETHOD Del(PRInt32 aID, void* anEntry, PRUint32 aLength) ;
+
+  NS_IMETHOD GetID(const char* key, PRUint32 length, PRInt32* aID) ;
+
+  NS_IMETHOD EnumEntry(void* *anEntry, PRUint32* aLength, PRBool bReset) ;
+  
+  NS_IMETHOD GetDBFilesize(PRUint32* aSize) ;
+  
+  NS_IMETHOD GetSpecialEntry(void** anEntry, PRUint32 *aLength) ;
+  NS_IMETHOD SetSpecialEntry(void* anEntry, PRUint32 aLength) ;
+
+  protected:
+  nsresult Sync(void) ;
+
+  private:
+  DB *                          mDB ;
+  nsCOMPtr<nsIFileSpec>         mDBFile ;
+  PRInt16                       mSessionID ;
+  PRInt16                       mSessionCntr ;
+  PRIntervalTime                mLastSyncTime ;
+  PRUint32                      mDBFilesize ; // cached DB filesize, 
+                                              // updated on every sync for now
+} ;
+
+#endif // _NSIDBACCESSOR_H_

mozilla/netwerk/cache/filecache/nsDBEnumerator.cpp

@@ -0,0 +1,108 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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 Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+/*
+ * This file is part of filecache implementation.
+ *
+ * It implements a simple iterator for the database, see nsDBAccessor. 
+ */
+
+#include "nsDBEnumerator.h"
+#include "nsDiskCacheRecord.h"
+
+nsDBEnumerator::nsDBEnumerator(nsIDBAccessor* aDB, nsNetDiskCache* aCache) :
+  m_DB(aDB) ,
+  m_DiskCache(aCache) ,
+  m_tempEntry(0) ,
+  m_tempEntry_length(0) ,
+  m_CacheEntry(0) ,
+  m_bReset(PR_TRUE) 
+{
+  NS_INIT_REFCNT();
+
+}
+
+nsDBEnumerator::~nsDBEnumerator()
+{
+  NS_IF_RELEASE(m_CacheEntry) ;
+}
+
+//
+// Implement nsISupports methods
+//
+NS_IMPL_ISUPPORTS(nsDBEnumerator, NS_GET_IID(nsIEnumerator))
+
+/////////////////////////////////////////////////////////////////
+// nsISimpleEnumerator methods
+
+NS_IMETHODIMP
+nsDBEnumerator::HasMoreElements(PRBool *_retval)
+{
+  *_retval = PR_FALSE ;
+
+  nsresult rv = m_DB->EnumEntry(&m_tempEntry, &m_tempEntry_length, m_bReset) ;
+
+  if(NS_FAILED(rv)) {
+    // do some error recovery
+    m_DiskCache->DBRecovery() ;
+    return rv ;
+  }
+
+  m_bReset = PR_FALSE ;
+
+  if(m_tempEntry && m_tempEntry_length != 0)
+    *_retval = PR_TRUE ;
+
+  return NS_OK ;
+}
+
+// this routine does not create a new item by itself  
+// Rather it reuses the item inside the object. So if you need to use the 
+// item later, you have to
+// create a new item specifically, using copy constructor or some other dup 
+// function. And don't forget to release it after you're done
+//
+NS_IMETHODIMP
+nsDBEnumerator::GetNext(nsISupports **_retval)
+{
+  if(!m_CacheEntry) {
+    m_CacheEntry = new nsDiskCacheRecord(m_DB, m_DiskCache) ;
+    if(m_CacheEntry)
+      NS_ADDREF(m_CacheEntry) ;
+    else
+      return NS_ERROR_OUT_OF_MEMORY ;
+  }
+
+  if(!_retval)
+    return NS_ERROR_NULL_POINTER ;
+  *_retval = nsnull ;
+
+  nsresult rv = m_CacheEntry->RetrieveInfo(m_tempEntry, m_tempEntry_length) ;
+  if(NS_FAILED(rv))
+    return rv ;
+
+  *_retval = NS_STATIC_CAST(nsISupports*, m_CacheEntry) ;
+  NS_ADDREF(*_retval) ; // all good getter addref 
+
+  return NS_OK ;
+}

mozilla/netwerk/cache/filecache/nsDBEnumerator.h

@@ -0,0 +1,60 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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 Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+/*
+ * This file is part of filecache implementation.
+ *
+ * It implements a simple iterator for the database, see nsDBAccessor. 
+ */
+
+#ifndef _NS_DBENUMERATOR_H_
+#define _NS_DBENUMERATOR_H_
+
+#include "nsISimpleEnumerator.h"
+#include "nsINetDataCacheRecord.h"
+#include "nsIDBAccessor.h"
+#include "nsCOMPtr.h"
+#include "nsNetDiskCache.h"
+#include "nsDiskCacheRecord.h"
+
+class nsCachedDiskData ; /* forward decl */
+
+class nsDBEnumerator : public nsISimpleEnumerator {
+public:
+    NS_DECL_ISUPPORTS
+
+    NS_DECL_NSISIMPLEENUMERATOR 
+
+    nsDBEnumerator(nsIDBAccessor* aDB, nsNetDiskCache* aCache) ;
+    virtual ~nsDBEnumerator() ;
+
+private:
+    nsCOMPtr<nsIDBAccessor>                m_DB ;
+    nsCOMPtr<nsNetDiskCache>               m_DiskCache ;
+    void *                                 m_tempEntry ;
+    PRUint32                               m_tempEntry_length ;
+    nsDiskCacheRecord*                     m_CacheEntry ;
+    PRBool                                 m_bReset ;
+};
+
+#endif // _NS_DBENUMERATOR_H_

mozilla/netwerk/cache/filecache/nsDiskCacheRecord.cpp

@@ -0,0 +1,456 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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 Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+#include "nsDiskCacheRecord.h"
+#include "nsINetDataDiskCache.h"
+#include "nsNetDiskCacheCID.h"
+#include "nsDiskCacheRecordChannel.h"
+#include "nsFileStream.h"
+
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+#include "nsIProtocolHandler.h"
+#include "nsIIOService.h"
+#include "nsIAllocator.h"
+
+#include "plstr.h"
+#include "prprf.h"
+#include "prmem.h"
+#include "prlog.h"
+#include "prtypes.h"
+#include "netCore.h"
+
+#include "nsDBAccessor.h"
+
+#if !defined(IS_LITTLE_ENDIAN) && !defined(IS_BIG_ENDIAN)
+ERROR! Must have a byte order
+#endif
+
+#ifdef IS_LITTLE_ENDIAN
+#define COPY_INT32(_a,_b)  memcpy(_a, _b, sizeof(int32))
+#else
+#define COPY_INT32(_a,_b)  /* swap */                   \
+    do {                                                \
+    ((char *)(_a))[0] = ((char *)(_b))[3];              \
+    ((char *)(_a))[1] = ((char *)(_b))[2];              \
+    ((char *)(_a))[2] = ((char *)(_b))[1];              \
+    ((char *)(_a))[3] = ((char *)(_b))[0];              \
+    } while(0)
+#endif
+
+nsDiskCacheRecord::nsDiskCacheRecord(nsIDBAccessor* db, nsNetDiskCache* aCache) :
+  mKey(0) ,
+  mKeyLength(0) ,
+  mRecordID(0) ,
+  mMetaData(0) ,
+  mMetaDataLength(0) ,
+  mDB(db) ,
+  mInfo(0) ,
+  mInfoSize(0) ,
+  mNumChannels(0) ,
+  mDiskCache(aCache) 
+{
+  NS_INIT_REFCNT();
+  NS_ASSERTION(mDiskCache, "Must have an nsNetDiskCache");
+  NS_ADDREF(mDiskCache);
+}
+
+// mem alloced. so caller should do free() on key. 
+NS_IMETHODIMP
+nsDiskCacheRecord::Init(const char* key, PRUint32 length, PRInt32 ID) 
+{
+  NS_NewFileSpec(getter_AddRefs(mFile));
+  if(!mFile)
+    return NS_ERROR_OUT_OF_MEMORY ;
+
+  // copy key
+  mKeyLength = length ;
+  mKey = NS_STATIC_CAST(char*, nsAllocator::Alloc(mKeyLength*sizeof(char))) ;
+  if(!mKey) 
+    return NS_ERROR_OUT_OF_MEMORY ;
+
+  memcpy(mKey, key, length) ;
+
+  // get RecordID
+  mRecordID = ID ;
+
+  // setup the file name
+  nsCOMPtr<nsIFileSpec> dbFolder ;
+  mDiskCache->GetDiskCacheFolder(getter_AddRefs(dbFolder)) ;
+
+  nsresult rv = mFile->FromFileSpec(dbFolder) ;
+  if(NS_FAILED(rv))
+    return NS_ERROR_FAILURE ;
+
+  // dir is a hash result of mRecordID%32, hope it's enough 
+  char filename[9], dirName[3] ;
+  
+  PR_snprintf(dirName, 3, "%02x", (((PRUint32)mRecordID) % 32)) ;
+  mFile->AppendRelativeUnixPath(dirName) ;
+
+  PR_snprintf(filename, 9, "%08x", mRecordID) ;
+  mFile->AppendRelativeUnixPath(filename) ;
+
+  return NS_OK ;
+}
+
+nsDiskCacheRecord::~nsDiskCacheRecord()
+{
+  if(mKey)
+    nsAllocator::Free(mKey) ;
+  if(mMetaData)
+    nsAllocator::Free(mMetaData) ;
+  if(mInfo) 
+    nsAllocator::Free(mInfo) ;
+
+  NS_IF_RELEASE(mDiskCache);
+}
+
+//
+// Implement nsISupports methods
+//
+NS_IMPL_ISUPPORTS(nsDiskCacheRecord, NS_GET_IID(nsINetDataCacheRecord))
+
+///////////////////////////////////////////////////////////////////////
+// nsINetDataCacheRecord methods
+
+// yes, mem alloced on *_retval.
+NS_IMETHODIMP
+nsDiskCacheRecord::GetKey(PRUint32 *length, char** _retval) 
+{
+  if(!_retval)
+    return NS_ERROR_NULL_POINTER ;
+
+  *length = mKeyLength ;
+  *_retval = NS_STATIC_CAST(char*, nsAllocator::Alloc(mKeyLength*sizeof(char))) ;
+  if(!*_retval)
+    return NS_ERROR_OUT_OF_MEMORY ;
+
+  memcpy(*_retval, mKey, mKeyLength) ;
+
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecord::GetRecordID(PRInt32* aRecordID)
+{
+  *aRecordID = mRecordID ;
+  return NS_OK ;
+}
+
+// yes, mem alloced on *_retval. 
+NS_IMETHODIMP
+nsDiskCacheRecord::GetMetaData(PRUint32 *length, char **_retval) 
+{
+  if(!_retval)
+    return NS_ERROR_NULL_POINTER ;
+
+  // always null the return value first. 
+  *_retval = nsnull ;
+
+  *length = mMetaDataLength ;
+
+  if(mMetaDataLength) {
+    *_retval = NS_STATIC_CAST(char*, nsAllocator::Alloc(mMetaDataLength*sizeof(char))) ;
+    if(!*_retval)
+      return NS_ERROR_OUT_OF_MEMORY ;
+
+    memcpy(*_retval, mMetaData, mMetaDataLength) ;
+  }
+
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecord::SetMetaData(PRUint32 length, const char* data)
+{
+  // set the mMetaData
+  mMetaDataLength = length ;
+  if(mMetaData)
+    nsAllocator::Free(mMetaData) ;
+  mMetaData = NS_STATIC_CAST(char*, nsAllocator::Alloc(mMetaDataLength*sizeof(char))) ;
+  if(!mMetaData) {
+    return NS_ERROR_OUT_OF_MEMORY ;
+  }
+  memcpy(mMetaData, data, length) ;
+
+  // Generate mInfo
+  nsresult rv = GenInfo() ;
+  if(NS_FAILED(rv))
+    return rv ;
+
+  // write through into mDB
+  rv = mDB->Put(mRecordID, mInfo, mInfoSize) ;
+
+  return rv ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecord::GetStoredContentLength(PRUint32 *aStoredContentLength)
+{
+  return mFile->GetFileSize(aStoredContentLength) ;
+}
+
+// untill nsIFileSpec::Truncate() is in, we have to do all this ugly stuff
+NS_IMETHODIMP
+nsDiskCacheRecord::SetStoredContentLength(PRUint32 aStoredContentLength)
+{
+  PRUint32 len = 0 ;
+  nsresult rv = mFile->GetFileSize(&len) ;
+  if(NS_FAILED(rv))
+    return rv ;
+
+  if(len < aStoredContentLength)
+  {
+    NS_ERROR("Error: can not set filesize to something bigger than itself.\n") ;
+    return NS_ERROR_FAILURE ;
+  }
+  else {
+    rv = mFile->Truncate(aStoredContentLength) ;
+    if(NS_FAILED(rv))
+      return rv ;
+    
+    mDiskCache->m_StorageInUse -= (len - aStoredContentLength) ;
+    return NS_OK ;
+  }
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecord::Delete(void)
+{
+  if(mNumChannels)
+    return NS_ERROR_NOT_AVAILABLE ;
+
+  PRUint32 len ;
+  mFile->GetFileSize(&len) ;
+
+  nsFileSpec cache_file ;
+  nsresult rv = mFile->GetFileSpec(&cache_file) ;
+
+  if(NS_FAILED(rv)) 
+    return NS_ERROR_FAILURE ;
+
+  cache_file.Delete(PR_TRUE) ;
+
+  // updata the storage size
+  mDiskCache->m_StorageInUse -= len ;
+
+  rv = mDB->Del(mRecordID, mKey, mKeyLength) ;
+  if(NS_FAILED(rv)) 
+    return NS_ERROR_FAILURE ;
+  else
+    return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecord::GetFilename(nsIFileSpec * *aFilename) 
+{
+  if(!aFilename)
+    return NS_ERROR_NULL_POINTER ;
+
+  *aFilename = mFile ;
+  NS_ADDREF(*aFilename) ;
+
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecord::NewChannel(nsILoadGroup *loadGroup, nsIChannel **_retval) 
+{
+  nsDiskCacheRecordChannel* channel = new nsDiskCacheRecordChannel(this, loadGroup) ;
+  if(!channel) 
+    return NS_ERROR_OUT_OF_MEMORY ;
+
+  nsresult rv = channel->Init() ;
+  if(NS_FAILED(rv))
+    return rv ;
+
+  NS_ADDREF(channel) ;
+  *_retval = NS_STATIC_CAST(nsIChannel*, channel) ;
+  return NS_OK ;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// nsDiskCacheRecord methods
+
+// file name is represented by a url string. I hope this would be more
+// generic
+nsresult
+nsDiskCacheRecord::GenInfo() 
+{
+  if(mInfo)
+    nsAllocator::Free(mInfo) ;
+
+  char* file_url=nsnull ;
+  PRUint32 name_len ;
+  mFile->GetURLString(&file_url) ;
+  name_len = PL_strlen(file_url)+1 ;
+
+  mInfoSize  = sizeof(PRUint32) ;    // checksum for mInfoSize
+  mInfoSize += sizeof(PRInt32) ;     // RecordID
+  mInfoSize += sizeof(PRUint32) ;    // key length
+  mInfoSize += mKeyLength ;          // key 
+  mInfoSize += sizeof(PRUint32) ;    // metadata length
+  mInfoSize += mMetaDataLength ;     // metadata 
+  mInfoSize += sizeof(PRUint32) ;    // filename length
+  mInfoSize += name_len ;            // filename 
+
+  void* newInfo = nsAllocator::Alloc(mInfoSize*sizeof(char)) ;
+  if(!newInfo) {
+    return NS_ERROR_OUT_OF_MEMORY ;
+  }
+
+  // copy the checksum mInfoSize
+  char* cur_ptr = NS_STATIC_CAST(char*, newInfo) ;
+  COPY_INT32(cur_ptr, &mInfoSize) ;
+  cur_ptr += sizeof(PRUint32) ;
+
+  // copy RecordID
+  COPY_INT32(cur_ptr, &mRecordID) ;
+  cur_ptr += sizeof(PRInt32) ;
+
+  // copy key length
+  COPY_INT32(cur_ptr, &mKeyLength) ;
+  cur_ptr += sizeof(PRUint32) ;
+
+  // copy key
+  memcpy(cur_ptr, mKey, mKeyLength) ;
+  cur_ptr += mKeyLength ;
+
+  // copy metadata length
+  COPY_INT32(cur_ptr, &mMetaDataLength) ;
+  cur_ptr += sizeof(PRUint32) ;
+
+  // copy metadata
+  memcpy(cur_ptr, mMetaData, mMetaDataLength) ;
+  cur_ptr += mMetaDataLength ;
+
+  // copy file name length 
+  COPY_INT32(cur_ptr, &name_len) ;
+  cur_ptr += sizeof(PRUint32) ;
+
+  // copy file name
+  memcpy(cur_ptr, file_url, name_len) ;
+  cur_ptr += name_len ;
+
+  PR_ASSERT(cur_ptr == NS_STATIC_CAST(char*, newInfo) + mInfoSize);
+  mInfo = newInfo ;
+
+  return NS_OK ;
+}
+
+/*
+ * This Method suppose to get all the info from the db record
+ * and set them to accroding members. the original values
+ * will all be overwritten. only minimal error checking is performed.
+ */
+NS_IMETHODIMP
+nsDiskCacheRecord::RetrieveInfo(void* aInfo, PRUint32 aInfoLength) 
+{
+  // reset everything
+  if(mInfo) {
+    nsAllocator::Free(mInfo) ;
+    mInfo = nsnull ;
+  }
+
+  if(mKey) {
+    nsAllocator::Free(mKey) ;
+    mKey = nsnull ;
+  }
+  if(mMetaData) {
+    nsAllocator::Free(mMetaData) ;
+    mMetaData = nsnull ;
+  }
+
+  char * cur_ptr = NS_STATIC_CAST(char*, aInfo) ;
+
+  char* file_url ;
+  PRUint32 name_len ;
+
+  // set mInfoSize 
+  COPY_INT32(&mInfoSize, cur_ptr) ;
+  cur_ptr += sizeof(PRUint32) ;
+
+  // check this at least
+  if(mInfoSize != aInfoLength) 
+    return NS_ERROR_FAILURE ;
+
+  // set mRecordID 
+  COPY_INT32(&mRecordID, cur_ptr) ;
+  cur_ptr += sizeof(PRInt32) ;
+
+  // set mKeyLength
+  COPY_INT32(&mKeyLength, cur_ptr) ;
+  cur_ptr += sizeof(PRUint32) ;
+
+  // set mKey
+  mKey = NS_STATIC_CAST(char*, nsAllocator::Alloc(mKeyLength*sizeof(char))) ;
+  if(!mKey) 
+    return NS_ERROR_OUT_OF_MEMORY ;
+  
+  memcpy(mKey, cur_ptr, mKeyLength) ;
+  cur_ptr += mKeyLength ;
+
+  PRInt32 id ;
+  mDB->GetID(mKey, mKeyLength, &id) ;
+  NS_ASSERTION(id==mRecordID, "\t ++++++ bad record, somethings wrong\n") ;
+
+  // set mMetaDataLength
+  COPY_INT32(&mMetaDataLength, cur_ptr) ;
+  cur_ptr += sizeof(PRUint32) ;
+
+  // set mMetaData
+  mMetaData = NS_STATIC_CAST(char*, nsAllocator::Alloc(mMetaDataLength*sizeof(char))) ;
+  if(!mMetaData) 
+    return NS_ERROR_OUT_OF_MEMORY ;
+  
+  memcpy(mMetaData, cur_ptr, mMetaDataLength) ;
+  cur_ptr += mMetaDataLength ;
+
+  // get mFile name length
+  COPY_INT32(&name_len, cur_ptr) ;
+  cur_ptr += sizeof(PRUint32) ;
+
+  // get mFile native name
+  file_url = NS_STATIC_CAST(char*, nsAllocator::Alloc(name_len*sizeof(char))) ;
+  if(!file_url) 
+    return NS_ERROR_OUT_OF_MEMORY ;
+  
+  memcpy(file_url, cur_ptr, name_len) ;
+  cur_ptr += name_len ;
+
+  PR_ASSERT(cur_ptr == NS_STATIC_CAST(char*, aInfo) + mInfoSize);
+
+  // create mFile if Init() isn't called 
+  if(!mFile) {
+    NS_NewFileSpec(getter_AddRefs(mFile));
+    if(!mFile)
+      return NS_ERROR_OUT_OF_MEMORY ;
+  }
+
+  // setup mFile
+  mFile->SetURLString(file_url) ;
+
+  return NS_OK ;
+}
+

mozilla/netwerk/cache/filecache/nsDiskCacheRecord.h

@@ -0,0 +1,71 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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 Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+#ifndef _NET_CACHEDDISKDATA_H_
+#define _NET_CACHEDDISKDATA_H_
+
+#include "nsINetDataCacheRecord.h"
+#include "nsCOMPtr.h"
+#include "nsIDBAccessor.h"
+#include "prtypes.h"
+#include "nsILoadGroup.h"
+#include "nsIFileChannel.h" 
+#include "nsNetDiskCache.h"
+
+class nsDiskCacheRecord : public nsINetDataCacheRecord
+{
+  public:
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSINETDATACACHERECORD
+
+  protected: 
+
+  nsDiskCacheRecord(nsIDBAccessor* db, nsNetDiskCache* aCache) ;
+  virtual ~nsDiskCacheRecord() ;
+
+  NS_IMETHOD RetrieveInfo(void* aInfo, PRUint32 aInfoLength) ;
+  NS_IMETHOD Init(const char* key, PRUint32 length, PRInt32 ID) ;
+
+  nsresult GenInfo(void) ;
+
+  private:
+
+  char*                     mKey ;
+  PRUint32                  mKeyLength ;
+  PRInt32                   mRecordID ;
+  char*                     mMetaData ;
+  PRUint32                  mMetaDataLength ;
+  nsCOMPtr<nsIFileSpec>     mFile ;
+  nsCOMPtr<nsIDBAccessor>            mDB ; 
+  void*                     mInfo ;
+  PRUint32                  mInfoSize ;
+  PRUint32                  mNumChannels ;
+  nsNetDiskCache*           mDiskCache ;
+
+  friend class nsDiskCacheRecordChannel ;
+  friend class nsDBEnumerator ;
+  friend class nsNetDiskCache ;
+} ;
+
+#endif // _NET_CACHEDDISKDATA_H_

mozilla/netwerk/cache/filecache/nsDiskCacheRecordChannel.cpp

@@ -0,0 +1,552 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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 Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+/*
+ * Most of the code are taken from nsFileChannel.  
+ */
+
+#include "nsDiskCacheRecordChannel.h"
+#include "nsIFileTransportService.h"
+//#include "nsIIOService.h"
+#include "nsIServiceManager.h"
+#include "nsIURL.h"
+#include "nsIOutputStream.h"
+#include "netCore.h"
+#include "nsIMIMEService.h"
+#include "nsISupportsUtils.h"
+
+//static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
+static NS_DEFINE_CID(kFileTransportServiceCID, NS_FILETRANSPORTSERVICE_CID);
+static NS_DEFINE_CID(kStandardURLCID, NS_STANDARDURL_CID);
+static NS_DEFINE_CID(kMIMEServiceCID, NS_MIMESERVICE_CID);
+
+// This is copied from nsMemCacheChannel, We should consolidate these two.
+class WriteStreamWrapper : public nsIOutputStream 
+{
+  public:
+  WriteStreamWrapper(nsDiskCacheRecordChannel* aChannel,
+                     nsIOutputStream *aBaseStream) ;
+
+  virtual ~WriteStreamWrapper() ;
+
+  static nsresult
+  Create(nsDiskCacheRecordChannel* aChannel, nsIOutputStream *aBaseStream, nsIOutputStream* *aWrapper) ;
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIBASESTREAM
+  NS_DECL_NSIOUTPUTSTREAM
+
+  private:
+  nsDiskCacheRecordChannel*         mChannel;
+  nsCOMPtr<nsIOutputStream>         mBaseStream;
+} ;
+
+// implement nsISupports
+NS_IMPL_ISUPPORTS(WriteStreamWrapper, NS_GET_IID(nsIOutputStream))
+
+WriteStreamWrapper::WriteStreamWrapper(nsDiskCacheRecordChannel* aChannel, 
+                                       nsIOutputStream *aBaseStream) 
+  : mChannel(aChannel), mBaseStream(aBaseStream)
+{ 
+  NS_INIT_REFCNT(); 
+  NS_ADDREF(mChannel);
+}
+
+WriteStreamWrapper::~WriteStreamWrapper()
+{
+  NS_RELEASE(mChannel);
+}
+
+nsresult 
+WriteStreamWrapper::Create(nsDiskCacheRecordChannel*aChannel, nsIOutputStream *aBaseStream, nsIOutputStream* * aWrapper) 
+{
+  WriteStreamWrapper *wrapper = new WriteStreamWrapper(aChannel, aBaseStream);
+  if (!wrapper) return NS_ERROR_OUT_OF_MEMORY;
+    NS_ADDREF(wrapper);
+  *aWrapper = wrapper;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+WriteStreamWrapper::Write(const char *aBuffer, PRUint32 aCount, PRUint32 *aNumWritten) 
+{
+  *aNumWritten = 0;
+  nsresult rv = mBaseStream->Write(aBuffer, aCount, aNumWritten);
+  mChannel->NotifyStorageInUse(*aNumWritten);
+  return rv;
+}
+
+NS_IMETHODIMP
+WriteStreamWrapper::Flush() 
+{ 
+  return mBaseStream->Flush(); 
+}
+
+NS_IMETHODIMP
+WriteStreamWrapper::Close() 
+{ 
+  return mBaseStream->Close(); 
+}
+
+nsDiskCacheRecordChannel::nsDiskCacheRecordChannel(nsDiskCacheRecord *aRecord, 
+                                                   nsILoadGroup *aLoadGroup)
+  : mRecord(aRecord) ,
+    mLoadGroup(aLoadGroup) 
+{
+  NS_INIT_REFCNT() ;
+  NS_ADDREF(mRecord);
+  mRecord->mNumChannels++ ;
+}
+
+nsDiskCacheRecordChannel::~nsDiskCacheRecordChannel()
+{
+  mRecord->mNumChannels-- ;
+  NS_RELEASE(mRecord);
+}
+
+//  I know that I gave conflicting advice on the issue of file
+//  transport versus file protocol handler, but I thought that the
+//  last word was that we would use the raw transport, when I wrote:
+//
+//   > I just thought of an argument for the other side of the coin, i.e. the
+//   > benefit of *not* reusing the file protocol handler: On the Mac, it's
+//   > expensive to convert from a string URL to an nsFileSpec, because the Mac
+//   > is brain-dead and scans every directory on the path to the file.  It's
+//   > cheaper to create a nsFileSpec for a cache file by combining a single,
+//   > static nsFileSpec that corresponds to the cache directory with the
+//   > relative path to the cache file (using nsFileSpec's operator +).  This
+//   > operation is optimized on the Mac to avoid the scanning operation.
+//
+//  The Mac guys will eat us alive if we do path string to nsFileSpec
+//  conversions for every cache file we open.
+
+nsresult 
+nsDiskCacheRecordChannel::Init(void) 
+{
+  nsresult rv = mRecord->mFile->GetFileSpec(&mSpec) ;
+  
+#ifdef XP_MAC
+
+  // Don't assume we actually created a good file spec
+  FSSpec theSpec = mSpec.GetFSSpec();
+  if (!theSpec.name[0]) {
+    NS_ERROR("failed to create a file spec");
+
+    // Since we didn't actually create the file spec
+    // we return an error
+    return NS_ERROR_MALFORMED_URI;
+  }
+#endif
+  
+  return rv ;
+
+}
+
+nsresult 
+nsDiskCacheRecordChannel::NotifyStorageInUse(PRInt32 aBytesUsed)
+{
+  return mRecord->mDiskCache->m_StorageInUse += aBytesUsed ;
+}
+
+// implement nsISupports
+NS_IMPL_ISUPPORTS4(nsDiskCacheRecordChannel, 
+                   nsIChannel, 
+                   nsIRequest,
+                   nsIStreamListener,
+                   nsIStreamObserver)
+
+// implement nsIRequest
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::IsPending(PRBool *aIsPending) 
+{
+  *aIsPending = PR_FALSE ;
+  if(!mFileTransport)
+    return NS_OK ;
+
+  return mFileTransport->IsPending(aIsPending) ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::Cancel(void)
+{
+  if(!mFileTransport)
+    return NS_ERROR_FAILURE ;
+
+  return mFileTransport->Cancel() ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::Suspend(void)
+{
+  if(!mFileTransport)
+    return NS_ERROR_FAILURE ;
+
+  return mFileTransport->Suspend() ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::Resume(void)
+{
+  if(!mFileTransport)
+    return NS_ERROR_FAILURE ;
+
+  return mFileTransport->Resume() ;
+}
+
+// implement nsIChannel
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::GetOriginalURI(nsIURI* *aURI)
+{
+  // FUR - might need to implement this - not sure
+  return NS_ERROR_NOT_IMPLEMENTED ;
+}
+  
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::GetURI(nsIURI * *aURI)
+{
+  if(!mFileTransport)
+    return NS_ERROR_FAILURE ;
+
+  return mFileTransport->GetURI(aURI) ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::OpenInputStream(PRUint32 aStartPosition, 
+                                          PRInt32 aReadCount,
+                                          nsIInputStream* *aResult)
+{
+  nsresult rv ;
+
+  if(mFileTransport)
+    return NS_ERROR_IN_PROGRESS ;
+
+  NS_WITH_SERVICE(nsIFileTransportService, fts, kFileTransportServiceCID, &rv) ;
+  if(NS_FAILED(rv)) return rv ;
+  
+  rv = fts->CreateTransport(mSpec, "load", 0, 0, getter_AddRefs(mFileTransport)) ;
+  if(NS_FAILED(rv))
+    return rv ;
+  
+  // we don't need to worry about notification callbacks
+  
+  rv = mFileTransport->OpenInputStream(aStartPosition, aReadCount, aResult) ;
+  if(NS_FAILED(rv)) 
+    mFileTransport = nsnull ;
+
+  return rv ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::OpenOutputStream(PRUint32 startPosition, 
+                                           nsIOutputStream* *aResult)
+{
+  nsresult rv ;
+  NS_ENSURE_ARG(aResult) ;
+  
+  if(mFileTransport)
+    return NS_ERROR_IN_PROGRESS ;
+
+  nsCOMPtr<nsIOutputStream> outputStream ;
+
+  NS_WITH_SERVICE(nsIFileTransportService, fts, kFileTransportServiceCID, &rv) ;
+  if(NS_FAILED(rv)) return rv ;
+  
+  rv = fts->CreateTransport(mSpec, "load", 0, 0, getter_AddRefs(mFileTransport)) ;
+  if(NS_FAILED(rv))
+    return rv ;
+ 
+  // we don't need to worry about notification callbacks
+  
+  rv = mFileTransport->OpenOutputStream(startPosition, getter_AddRefs(outputStream)) ;
+  if(NS_FAILED(rv)) {
+    mFileTransport = nsnull ;
+    return rv ;
+  }
+ 
+  return WriteStreamWrapper::Create(this, outputStream, aResult) ;
+
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::AsyncOpen(nsIStreamObserver *observer, 
+                                    nsISupports *ctxt)
+{
+  return NS_ERROR_NOT_IMPLEMENTED ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::AsyncRead(PRUint32 aStartPosition, 
+                                    PRInt32 aReadCount,
+                                    nsISupports *aContext, 
+                                    nsIStreamListener *aListener)
+{
+  nsresult rv ;
+
+  if(mFileTransport)
+    return NS_ERROR_IN_PROGRESS ;
+  
+  mRealListener = aListener;
+  nsCOMPtr<nsIStreamListener> tempListener = this;
+
+  if (mLoadGroup) {
+    nsCOMPtr<nsILoadGroupListenerFactory> factory;
+    //
+    // Create a load group "proxy" listener...
+    //
+    rv = mLoadGroup->GetGroupListenerFactory(getter_AddRefs(factory));
+    if (factory) {
+      nsIStreamListener *newListener;
+      rv = factory->CreateLoadGroupListener(mRealListener, &newListener);
+      if (NS_SUCCEEDED(rv)) {
+        mRealListener = newListener;
+        NS_RELEASE(newListener);
+        }
+      }
+
+      rv = mLoadGroup->AddChannel(this, nsnull);
+      if (NS_FAILED(rv)) return rv;
+  }
+
+
+  NS_WITH_SERVICE(nsIFileTransportService, fts, kFileTransportServiceCID, &rv);
+  if (NS_FAILED(rv)) return rv;
+
+  rv = fts->CreateTransport(mSpec, "load", 0, 0, getter_AddRefs(mFileTransport));
+  if (NS_FAILED(rv)) return rv;
+
+  // no callbacks
+
+  rv = mFileTransport->AsyncRead(aStartPosition, 
+                                 aReadCount, 
+                                 aContext, 
+                                 tempListener);
+
+  if (NS_FAILED(rv)) {
+    // release the transport so that we don't think we're in progress
+    mFileTransport = nsnull;
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::AsyncWrite(nsIInputStream *fromStream, 
+                                     PRUint32 startPosition,
+                                     PRInt32 writeCount, 
+                                     nsISupports *ctxt,
+                                     nsIStreamObserver *observer)
+
+{
+  /*
+  if(!mFileTransport)
+    return NS_ERROR_FAILURE ;
+
+  return mFileTransport->AsyncWrite(fromStream, 
+                                    startPosition,
+                                    writeCount,
+                                    ctxt,
+                                    observer) ;
+  */
+
+  // I can't do this since the write is not monitored, and I won't be
+  // able to updata the storage. 
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::GetLoadAttributes(nsLoadFlags *aLoadAttributes)
+{
+  // Not required to be implemented, since it is implemented by cache manager
+  NS_ASSERTION(0, "nsDiskCacheRecordChannel method unexpectedly called");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::SetLoadAttributes(nsLoadFlags aLoadAttributes)
+{
+  // Not required to be implemented, since it is implemented by cache manager
+  NS_ASSERTION(0, "nsDiskCacheRecordChannel method unexpectedly called");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+#define DUMMY_TYPE "text/html"
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::GetContentType(char * *aContentType)
+{
+  nsresult rv ;
+
+  if (mSpec.IsDirectory()) {
+    *aContentType = nsCRT::strdup("application/http-index-format");
+    return *aContentType ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+  }
+  else {
+    // I wish I can make this simplier
+
+    char* urlStr ;
+    mRecord->mFile->GetURLString(&urlStr) ;
+
+    // file: URLs (currently) have no additional structure beyond that provided by standard
+    // URLs, so there is no "outer" given to CreateInstance 
+
+    nsCOMPtr<nsIURI> url;
+    rv = nsComponentManager::CreateInstance(kStandardURLCID, nsnull,
+                                            NS_GET_IID(nsIURI),
+                                            //(void**)&url);
+                                            getter_AddRefs(url)) ;
+    if (NS_FAILED(rv)) return rv;
+
+    rv = url->SetSpec((char*)urlStr);
+    if (NS_FAILED(rv)) 
+        return rv;
+
+    NS_WITH_SERVICE(nsIMIMEService, MIMEService, kMIMEServiceCID, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    rv = MIMEService->GetTypeFromURI(url, aContentType);
+    if (NS_SUCCEEDED(rv)) return rv;
+  }
+
+  // if all else fails treat it as text/html?
+  *aContentType = nsCRT::strdup(DUMMY_TYPE);
+  if (!*aContentType) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  } else {
+    return NS_OK;
+  }
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::GetContentLength(PRInt32 *aContentLength)
+{
+  nsresult rv;
+  PRUint32 length;
+
+  rv = mRecord->mFile->GetFileSize(&length);
+  if (NS_SUCCEEDED(rv)) {
+    *aContentLength = (PRInt32)length;
+  } else {
+    *aContentLength = -1;
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::GetOwner(nsISupports* *aOwner)
+{
+  *aOwner = mOwner.get() ;
+  NS_IF_ADDREF(*aOwner) ;
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::SetOwner(nsISupports* aOwner) 
+{
+  mOwner = aOwner ;
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::GetLoadGroup(nsILoadGroup* *aLoadGroup)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsDiskCacheRecordChannel method unexpectedly called");
+      return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::SetLoadGroup(nsILoadGroup* aLoadGroup)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsDiskCacheRecordChannel method unexpectedly called");
+      return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::GetNotificationCallbacks(nsIInterfaceRequestor* *aNotificationCallbacks)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsDiskCacheRecordChannel method unexpectedly called");
+      return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::SetNotificationCallbacks(nsIInterfaceRequestor* aNotificationCallbacks)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsDiskCacheRecordChannel method unexpectedly called");
+      return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// nsIStreamListener methods:
+////////////////////////////////////////////////////////////////////////////////
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::OnStartRequest(nsIChannel* transportChannel, nsISupports* context)
+{
+  NS_ASSERTION(mRealListener, "No listener...");
+  return mRealListener->OnStartRequest(this, context);
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::OnStopRequest(nsIChannel* transportChannel, nsISupports* context,
+                             nsresult aStatus, const PRUnichar* aMsg)
+{
+  nsresult rv;
+
+  rv = mRealListener->OnStopRequest(this, context, aStatus, aMsg);
+
+  if (mLoadGroup) {
+    if (NS_SUCCEEDED(rv)) {
+      mLoadGroup->RemoveChannel(this, context, aStatus, aMsg);
+    }
+  }
+
+  // Release the reference to the consumer stream listener...
+  mRealListener = null_nsCOMPtr();
+  mFileTransport = null_nsCOMPtr();
+  return rv;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::OnDataAvailable(nsIChannel* transportChannel, nsISupports* context,
+                               nsIInputStream *aIStream, PRUint32 aSourceOffset,
+                               PRUint32 aLength)
+{
+  nsresult rv;
+
+  rv = mRealListener->OnDataAvailable(this, context, aIStream,
+                                      aSourceOffset, aLength);
+
+  //
+  // If the connection is being aborted cancel the transport.  This will
+  // insure that the transport will go away even if it is blocked waiting
+  // for the consumer to empty the pipe...
+  //
+  if (NS_FAILED(rv)) {
+    mFileTransport->Cancel();
+  }
+  return rv;
+}
+

mozilla/netwerk/cache/filecache/nsDiskCacheRecordChannel.h

@@ -0,0 +1,76 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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 Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+#ifndef _ns_DiskCacheRecordChannel_h_
+#define _ns_DiskCacheRecordChannel_h_
+
+#include "nsIChannel.h"
+#include "nsCOMPtr.h"
+#include "nsDiskCacheRecord.h"
+#include "nsIStreamListener.h"
+
+/*
+ * This class is plagiarized from nsMemCacheChannel
+ */
+
+class nsDiskCacheRecordChannel : public nsIChannel,
+                                 public nsIStreamListener 
+{
+  public:
+
+  nsDiskCacheRecordChannel(nsDiskCacheRecord *aRecord, nsILoadGroup *aLoadGroup);
+  virtual ~nsDiskCacheRecordChannel() ;
+
+  // Declare nsISupports methods
+  NS_DECL_ISUPPORTS
+
+  // Declare nsIRequest methods
+  NS_DECL_NSIREQUEST
+
+  // Declare nsIChannel methods
+  NS_DECL_NSICHANNEL
+
+  // Declare nsIStreamObserver methods
+  NS_DECL_NSISTREAMOBSERVER
+
+  // Declare nsIStreamListener methods
+  NS_DECL_NSISTREAMLISTENER
+
+  nsresult Init(void) ;
+
+  private:
+
+  nsresult NotifyStorageInUse(PRInt32 aBytesUsed) ;
+
+  nsDiskCacheRecord*                    mRecord ;
+  nsCOMPtr<nsILoadGroup>                mLoadGroup ;
+  nsCOMPtr<nsISupports>                 mOwner ;
+  nsCOMPtr<nsIChannel>                  mFileTransport ;
+  nsFileSpec                            mSpec ;
+  nsCOMPtr<nsIStreamListener>           mRealListener;
+
+  friend class WriteStreamWrapper ;
+} ;
+
+#endif // _ns_DiskCacheRecordChannel_h_
+

mozilla/netwerk/cache/filecache/nsIDBAccessor.h

@@ -0,0 +1,66 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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 Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+#ifndef _NS_IDBACCESSOR_H_
+#define _NS_IDBACCESSOR_H_
+
+#include "nsISupports.h"
+#include "nsIFileSpec.h"
+
+// nsIDBAccessorIID {6AADD4D0-7785-11d3-87FE-000629D01344}
+#define NS_IDBACCESSOR_IID \
+{ 0x6aadd4d0, 0x7785, 0x11d3, \
+ {0x87, 0xfe, 0x0, 0x6, 0x29, 0xd0, 0x13, 0x44}}
+
+// nsDBAccessorCID {6AADD4D1-7785-11d3-87FE-000629D01344}
+#define NS_DBACCESSOR_CID \
+{ 0x6aadd4d1, 0x7785, 0x11d3, \
+  { 0x87, 0xfe, 0x0, 0x6, 0x29, 0xd0, 0x13, 0x44 }} 
+
+class nsIDBAccessor : public nsISupports
+{
+  public:
+  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDBACCESSOR_IID)
+
+  NS_IMETHOD Init(nsIFileSpec* DBFile) = 0 ;
+  NS_IMETHOD Shutdown(void) = 0 ;
+
+  NS_IMETHOD Put(PRInt32 aID, void* anEntry, PRUint32 aLength) = 0 ;
+
+  NS_IMETHOD Get(PRInt32 aID, void** anEntry, PRUint32 *aLength) = 0 ;
+
+  NS_IMETHOD Del(PRInt32 aID, void* anEntry, PRUint32 aLength) = 0 ;
+
+  NS_IMETHOD GetID(const char* key, PRUint32 length, PRInt32* aID) = 0 ;
+
+  NS_IMETHOD EnumEntry(void* *anEntry, PRUint32* aLength, PRBool bReset) = 0 ;
+  
+  NS_IMETHOD GetDBFilesize(PRUint32* aSize) = 0 ;
+    
+  NS_IMETHOD GetSpecialEntry(void** anEntry, PRUint32 *aLength) = 0 ;
+  NS_IMETHOD SetSpecialEntry(void* anEntry, PRUint32 aLength) = 0 ;
+
+} ;
+
+#endif // _NS_IDBACCESSOR_H_
+

mozilla/netwerk/cache/filecache/nsNetDiskCache.cpp

@@ -0,0 +1,704 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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 Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+#include "nsNetDiskCache.h"
+#include "nscore.h"
+
+#include "plstr.h"
+#include "prprf.h"
+#include "prtypes.h"
+#include "prio.h"
+#include "prsystem.h" // Directory Seperator
+#include "plhash.h"
+#include "prclist.h"
+#include "prmem.h"
+#include "prlog.h"
+
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+
+#include "nsIPref.h"
+#include "mcom_db.h"
+#include "nsDBEnumerator.h"
+
+#include "nsDiskCacheRecord.h"
+#include "netCore.h"
+
+#if !defined(IS_LITTLE_ENDIAN) && !defined(IS_BIG_ENDIAN)
+ERROR! Must have a byte order
+#endif
+
+#ifdef IS_LITTLE_ENDIAN
+#define COPY_INT32(_a,_b)  memcpy(_a, _b, sizeof(int32))
+#else
+#define COPY_INT32(_a,_b)  /* swap */                   \
+    do {                                                \
+    ((char *)(_a))[0] = ((char *)(_b))[3];              \
+    ((char *)(_a))[1] = ((char *)(_b))[2];              \
+    ((char *)(_a))[2] = ((char *)(_b))[1];              \
+    ((char *)(_a))[3] = ((char *)(_b))[0];              \
+    } while(0)
+#endif
+
+static NS_DEFINE_CID(kPrefCID, NS_PREF_CID) ;
+static NS_DEFINE_CID(kDBAccessorCID, NS_DBACCESSOR_CID) ;
+
+static const PRUint32 DISK_CACHE_SIZE_DEFAULT = 5*1024*1024 ; // 5MB
+static const char * const DISK_CACHE_PREF  = "browser.cache.disk_cache_size";
+static const char * const CACHE_DIR_PREF   = "browser.cache.directory";
+
+class nsDiskCacheRecord ;
+
+nsNetDiskCache::nsNetDiskCache() :
+  m_Enabled(PR_TRUE) ,
+  m_NumEntries(0) ,
+  m_pNextCache(0) ,
+  m_pDiskCacheFolder(0) ,
+  m_StorageInUse(0) ,
+  m_DB(0) ,
+  m_DBCorrupted(PR_FALSE) 
+{
+  // set it to INF for now 
+  m_MaxEntries = (PRUint32)-1 ;
+
+  NS_INIT_REFCNT();
+
+}
+
+nsNetDiskCache::~nsNetDiskCache()
+{
+  SetSpecialEntry() ;
+
+  NS_IF_RELEASE(m_DB) ;
+  
+
+  // FUR
+  // I think that, eventually, we also want a distinguished key in the DB which
+  // means "clean cache shutdown".  You clear this flag when the db is first
+  // opened and set it just before the db is closed.  If the db wasn't shutdown
+  // cleanly in a prior session, i.e. because the app crashed, on startup you
+  // scan all the individual files in directories and look for "orphans",
+  // i.e. cache files which don't have corresponding entries in the db.  That's
+  // also when storage-in-use and number of entries would be recomputed.
+  //
+  // We don't necessarily need all this functionality immediately, though.
+
+
+  if(m_DBCorrupted) {
+    
+    nsFileSpec cacheFolder ;
+    m_pDiskCacheFolder->GetFileSpec(&cacheFolder) ;
+    
+    char nameInt[6] ;
+
+    for(nsDirectoryIterator di(cacheFolder, PR_FALSE); di.Exists(); di++) {
+      char* filename = di.Spec().GetLeafName() ;
+      char* pname = nameInt ;
+      pname = PL_strncpyz(pname, filename, 6) ;
+
+      if(PL_strcmp(pname, "trash") == 0)
+        RemoveFolder(di.Spec()) ;
+      
+      nsCRT::free(filename) ;  
+    }
+  }
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::Init(void) 
+{
+  nsresult rv ;
+  
+  // don't initialize if no cache folder is set. 
+  if(!m_pDiskCacheFolder) return NS_OK ;
+
+  if(!m_DB) {
+    m_DB = new nsDBAccessor() ;
+    if(!m_DB)
+      return NS_ERROR_OUT_OF_MEMORY ;
+    else
+      NS_ADDREF(m_DB) ;
+  }
+
+  // create cache sub directories
+  nsCOMPtr<nsIFileSpec> cacheSubDir;
+  rv = NS_NewFileSpec(getter_AddRefs(cacheSubDir));
+
+  for (int i=0; i < 32; i++) {
+    rv = cacheSubDir->FromFileSpec(m_pDiskCacheFolder) ;
+    if(NS_FAILED(rv))
+      return rv ;
+
+    char dirName[3];
+    PR_snprintf (dirName, 3, "%0.2x", i);
+    cacheSubDir->AppendRelativeUnixPath (dirName) ;
+    CreateDir(cacheSubDir);
+  }
+
+  return InitDB() ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::InitDB(void)
+{
+  nsresult rv ; 
+
+  if(!m_DBFile) {
+    NS_NewFileSpec(getter_AddRefs(m_DBFile)) ;
+    if(!m_DBFile)
+      return NS_ERROR_OUT_OF_MEMORY ;
+  }
+
+  rv = m_DBFile->FromFileSpec(m_pDiskCacheFolder) ;
+  if(NS_FAILED(rv))
+    return rv ;
+
+  m_DBFile->AppendRelativeUnixPath("cache.db") ;
+
+  rv = m_DB->Init(m_DBFile) ;
+
+  if(rv == NS_ERROR_FAILURE) {
+    // try recovery if error 
+    DBRecovery() ;
+  }
+
+  rv = GetSpecialEntry() ;
+  if(rv == NS_ERROR_FAILURE) {
+    // try recovery if error 
+    DBRecovery() ;
+  }
+
+  return rv ;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// nsISupports methods
+
+NS_IMPL_ISUPPORTS3(nsNetDiskCache,
+                   nsINetDataDiskCache,
+                   nsINetDataCache,
+                   nsISupports) 
+
+///////////////////////////////////////////////////////////////////////////
+// nsINetDataCache Method 
+
+NS_IMETHODIMP
+nsNetDiskCache::GetDescription(PRUnichar* *aDescription) 
+{
+  nsAutoString description("Disk Cache") ;
+  *aDescription = description.ToNewUnicode() ;
+  if(!*aDescription)
+    return NS_ERROR_OUT_OF_MEMORY ;
+
+  return NS_OK ;
+}
+
+/* don't alloc mem for nsICachedNetData. 
+ * RecordID is generated using the same scheme in nsCacheDiskData,
+ * see GetCachedNetData() for detail.
+ */
+NS_IMETHODIMP
+nsNetDiskCache::Contains(const char* key, PRUint32 length, PRBool *_retval) 
+{
+  *_retval = PR_FALSE ;
+
+  NS_ASSERTION(m_DB, "no db.") ;
+
+  PRInt32 id = 0 ;
+  nsresult rv = m_DB->GetID(key, length, &id) ;
+
+  if(NS_FAILED(rv)) {
+    // try recovery if error 
+    DBRecovery() ;
+    return rv ;
+  }
+
+  void* info = 0 ;
+  PRUint32 info_size = 0 ;
+
+  rv = m_DB->Get(id, &info, &info_size) ;
+  if(NS_SUCCEEDED(rv) && info) 
+    *_retval = PR_TRUE ;
+        
+  if(NS_FAILED(rv)) {
+    // try recovery if error 
+    DBRecovery() ;
+  }
+
+  return rv ;
+}
+
+/* regardless if it's cached or not, a copy of nsNetDiskCache would 
+ * always be returned. so release it appropriately. 
+ * if mem alloced, updata m_NumEntries also.
+ * for now, the new nsCachedNetData is not written into db yet since
+ * we have nothing to write.
+ */
+NS_IMETHODIMP
+nsNetDiskCache::GetCachedNetData(const char* key, PRUint32 length, nsINetDataCacheRecord **_retval) 
+{
+  NS_ASSERTION(m_DB, "no db.") ;
+
+  nsresult rv = 0 ;
+  if (!_retval)
+    return NS_ERROR_NULL_POINTER ;
+
+  *_retval = nsnull ;
+
+  PRInt32 id = 0 ;
+  rv = m_DB->GetID(key, length, &id) ;
+  if(NS_FAILED(rv)) {
+    // try recovery if error 
+    DBRecovery() ;
+    return rv ;
+  }
+
+  // construct an empty record
+  nsDiskCacheRecord* newRecord = new nsDiskCacheRecord(m_DB, this) ;
+  if(!newRecord) 
+    return NS_ERROR_OUT_OF_MEMORY ;
+
+  rv = newRecord->Init(key, length, id) ;
+  if(NS_FAILED(rv)) {
+    delete newRecord ;
+    return rv ;
+  }
+
+  NS_ADDREF(newRecord) ; // addref for _retval 
+  *_retval = (nsINetDataCacheRecord*) newRecord ;
+  
+  void* info = 0 ;
+  PRUint32 info_size = 0 ;
+
+  rv = m_DB->Get(id, &info, &info_size) ;
+  if(NS_SUCCEEDED(rv) && info) {
+
+    // this is a previously cached record 
+    nsresult r1 ;
+    r1 = newRecord->RetrieveInfo(info, info_size) ;
+
+    if(NS_SUCCEEDED(rv)) 
+      return NS_OK ;
+    else { 
+      // probably a bad one
+      NS_RELEASE(newRecord) ;
+      *_retval = nsnull ;
+      return r1;
+    }
+    
+  } else if (NS_SUCCEEDED(rv) && !info) {
+    // this is a new record. 
+    m_NumEntries ++ ;
+    return NS_OK ;
+  } else {
+    // database error.
+    DBRecovery() ;
+    return rv ;
+  }
+}
+
+/* get an nsICachedNetData, mem needs to be de-alloced if not found. */
+NS_IMETHODIMP
+nsNetDiskCache::GetCachedNetDataByID(PRInt32 RecordID, nsINetDataCacheRecord **_retval) 
+{
+  NS_ASSERTION(m_DB, "no db.") ;
+
+  if (!_retval)
+    return NS_ERROR_NULL_POINTER ;
+
+  *_retval = nsnull ;
+  
+  nsresult rv ;
+
+  void* info = 0 ;
+  PRUint32 info_size = 0 ;
+
+  rv = m_DB->Get(RecordID, &info, &info_size) ;
+  if(NS_SUCCEEDED(rv) && info) {
+
+    // construct an empty record if only found in db
+    nsDiskCacheRecord* newRecord = new nsDiskCacheRecord(m_DB, this) ;
+    if(!newRecord) 
+      return NS_ERROR_OUT_OF_MEMORY ;
+
+    NS_ADDREF(newRecord) ; // addref for _retval
+    rv = newRecord->RetrieveInfo(info, info_size) ;
+
+    if(NS_SUCCEEDED(rv)) {
+      *_retval = (nsINetDataCacheRecord*) newRecord ;
+      return NS_OK ;
+    } 
+    else {
+      // bad record, I guess
+      NS_RELEASE(newRecord) ; // release if bad things happen
+      return rv ;
+    }
+  } else {
+    NS_ERROR("Error: RecordID not in DB\n") ;
+    DBRecovery() ;
+    return rv ;
+  }
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::GetEnabled(PRBool *aEnabled) 
+{
+  *aEnabled = m_Enabled ;
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::SetEnabled(PRBool aEnabled) 
+{
+  m_Enabled = aEnabled ;
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::GetFlags(PRUint32 *aFlags) 
+{
+  *aFlags = FILE_PER_URL_CACHE;
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::GetNumEntries(PRUint32 *aNumEntries) 
+{
+  *aNumEntries = m_NumEntries ;
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::GetMaxEntries(PRUint32 *aMaxEntries)
+{
+  *aMaxEntries = m_MaxEntries ;
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::NewCacheEntryIterator(nsISimpleEnumerator **_retval) 
+{
+  NS_ASSERTION(m_DB, "no db.") ;
+
+  if(!_retval)
+    return NS_ERROR_NULL_POINTER ;
+
+  *_retval = nsnull ;
+
+  nsISimpleEnumerator* enumerator = new nsDBEnumerator(m_DB, this) ;
+  if(enumerator) {
+    NS_ADDREF(enumerator) ;
+    *_retval = enumerator ;
+    return NS_OK ;
+  }
+  else 
+    return NS_ERROR_OUT_OF_MEMORY ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::GetNextCache(nsINetDataCache * *aNextCache)
+{
+  if(!aNextCache)
+    return NS_ERROR_NULL_POINTER ;
+
+  *aNextCache = m_pNextCache ;
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::SetNextCache(nsINetDataCache *aNextCache)
+{
+  m_pNextCache = aNextCache ;
+  return NS_OK ;
+}
+
+// db size can always be measured at the last minute. Since it's hard
+// to know before hand. 
+NS_IMETHODIMP
+nsNetDiskCache::GetStorageInUse(PRUint32 *aStorageInUse)
+{
+  NS_ASSERTION(m_DB, "no db.") ;
+
+  PRUint32 total_size = m_StorageInUse ;
+
+  /*
+  PRUint32 len = 0 ;
+  // add the size of the db.
+  m_DB->GetDBFilesize(&len) ;
+  total_size += len ;
+  */
+
+  // we need size in kB
+  total_size = total_size >> 10 ;
+
+  *aStorageInUse = total_size ;
+  return NS_OK ;
+}
+
+/*
+ * The whole cache dirs can be whiped clean since all the cache 
+ * files are resides in seperate hashed dirs. It's safe to do so.
+ */
+ 
+NS_IMETHODIMP
+nsNetDiskCache::RemoveAll(void)
+{
+  NS_ASSERTION(m_DB, "no db.") ;
+  NS_ASSERTION(m_pDiskCacheFolder, "no cache folder.") ;
+
+  // remove all the sub folders
+  nsFileSpec cacheSubDir;
+
+  for (int i=0; i < 32; i++) {
+    m_pDiskCacheFolder->GetFileSpec(&cacheSubDir) ;
+
+    char dirName[3];
+    PR_snprintf (dirName, 3, "%0.2x", i);
+    cacheSubDir += dirName ;
+    RemoveFolder(cacheSubDir) ;
+  }
+
+  // don't forget the db file itself
+  m_DB->Shutdown() ;
+  nsFileSpec dbfile ;
+  m_DBFile->GetFileSpec(&dbfile) ;
+  dbfile.Delete(PR_TRUE) ;
+
+  // reinitilize
+  return Init() ;
+}
+
+//////////////////////////////////////////////////////////////////
+// nsINetDataDiskCache methods
+
+NS_IMETHODIMP
+nsNetDiskCache::GetDiskCacheFolder(nsIFileSpec * *aDiskCacheFolder)
+{
+  *aDiskCacheFolder = nsnull ;
+  NS_ASSERTION(m_pDiskCacheFolder, "no cache folder.") ;
+
+  *aDiskCacheFolder = m_pDiskCacheFolder ;
+  NS_ADDREF(*aDiskCacheFolder) ;
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::SetDiskCacheFolder(nsIFileSpec * aDiskCacheFolder)
+{
+  if(!m_pDiskCacheFolder) {
+    NS_NewFileSpec(getter_AddRefs(m_pDiskCacheFolder));
+    if(!m_pDiskCacheFolder) 
+      return NS_ERROR_OUT_OF_MEMORY ;
+    
+    m_pDiskCacheFolder = aDiskCacheFolder ;
+    return Init() ;
+  } 
+  else {
+    char *newfolder, *oldfolder ;
+    m_pDiskCacheFolder->GetNativePath(&oldfolder) ;
+    aDiskCacheFolder->GetNativePath(&newfolder) ;
+
+    if(PL_strcmp(newfolder, oldfolder) != 0) {
+      m_pDiskCacheFolder = aDiskCacheFolder ;
+
+      // do we need to blow away old cache before building a new one?
+      // return RemoveAll() ;
+
+      m_DB->Shutdown() ;
+      return Init() ;
+
+    } else 
+      return NS_OK ;
+  }
+}
+
+//////////////////////////////////////////////////////////////////
+// nsNetDiskCache methods
+
+// create a directory (recursively)
+NS_IMETHODIMP
+nsNetDiskCache::CreateDir(nsIFileSpec* dir_spec) 
+{
+  PRBool does_exist ;
+  nsCOMPtr<nsIFileSpec> p_spec ;
+
+  dir_spec->Exists(&does_exist) ;
+  if(does_exist) 
+    return NS_OK ;
+
+  nsresult rv = dir_spec->GetParent(getter_AddRefs(p_spec)) ;
+  if(NS_FAILED(rv))
+    return rv ;
+
+  p_spec->Exists(&does_exist) ;
+  if(!does_exist) {
+    CreateDir(p_spec) ;
+    rv = dir_spec->CreateDir() ;
+    if(NS_FAILED(rv))
+      return rv ;
+  }
+  else {
+    rv = dir_spec->CreateDir() ;
+    if(NS_FAILED(rv))
+      return rv ;
+  }
+  
+  return NS_OK ;
+}
+
+// We can't afford to make a *separate* pass over the whole db on every
+// startup, just to figure out m_NumEntries and m_StorageInUse.  (This is a
+// several second operation on a large db).  We'll likely need to store
+// distinguished keys in the db that contain these values and update them
+// incrementally, except when failure to shut down the db cleanly is detected.
+
+NS_IMETHODIMP
+nsNetDiskCache::GetSpecialEntry(void)
+{
+  void* pInfo ;
+  PRUint32 InfoSize ;
+
+  nsresult rv = m_DB->GetSpecialEntry(&pInfo, &InfoSize) ;
+  if(NS_FAILED(rv))
+    return rv ;
+
+  if(!pInfo && InfoSize == 0) {
+    // must be a new DB
+    m_NumEntries = 0 ;
+    m_StorageInUse = 0 ;
+  } 
+  else {
+    char * cur_ptr = NS_STATIC_CAST(char*, pInfo) ;
+    
+    // get m_NumEntries
+    COPY_INT32(&m_NumEntries, cur_ptr) ;
+    cur_ptr += sizeof(PRUint32) ;
+    
+    // get m_StorageInUse
+    COPY_INT32(&m_StorageInUse, cur_ptr) ;
+    cur_ptr += sizeof(PRUint32) ;
+    
+    PR_ASSERT(cur_ptr == NS_STATIC_CAST(char*, pInfo) + InfoSize);
+  }
+
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::SetSpecialEntry(void)
+{
+  PRUint32 InfoSize ;
+  
+  InfoSize = sizeof m_NumEntries ;
+  InfoSize += sizeof m_StorageInUse ;
+  
+  void* pInfo = nsAllocator::Alloc(InfoSize*sizeof(char)) ;
+  if(!pInfo) 
+    return NS_ERROR_OUT_OF_MEMORY ;
+  
+  char* cur_ptr = NS_STATIC_CAST(char*, pInfo) ;
+
+  COPY_INT32(cur_ptr, &m_NumEntries) ;
+  cur_ptr += sizeof(PRUint32) ;
+
+  COPY_INT32(cur_ptr, &m_StorageInUse) ;
+  cur_ptr += sizeof(PRUint32) ;
+  
+  PR_ASSERT(cur_ptr == NS_STATIC_CAST(char*, pInfo) + InfoSize);
+  
+  return m_DB->SetSpecialEntry(pInfo, InfoSize) ;
+}
+
+// this routine will be called everytime we have a db corruption. 
+// m_DB will be re-initialized, m_StorageInUse and m_NumEntries will
+// be reset.
+NS_IMETHODIMP
+nsNetDiskCache::DBRecovery(void)
+{
+  // rename all the sub cache dirs and remove them later during dtor. 
+  nsresult rv = RenameCacheSubDirs() ;
+  if(NS_FAILED(rv))
+    return rv ;
+
+  // remove corrupted db file, don't care if db->shutdown fails or not.
+  m_DB->Shutdown() ;
+  
+  nsFileSpec dbfile ;
+  m_DBFile->GetFileSpec(&dbfile) ;
+  dbfile.Delete(PR_TRUE) ;
+
+  // make sure it's not there any more
+  PRBool exists = dbfile.Exists() ;
+  if(exists) {
+    NS_ERROR("can't remove old db.") ;
+    return NS_ERROR_FAILURE ;
+  }
+
+  // reinitilize DB 
+  return InitDB() ;
+}
+
+// this routine will add string "trash" to current CacheSubDir names. 
+// e.g. 00->trash00, 1f->trash1f. and update the m_DBCorrupted. 
+
+NS_IMETHODIMP
+nsNetDiskCache::RenameCacheSubDirs(void) 
+{
+  nsCOMPtr<nsIFileSpec> cacheSubDir;
+  nsresult rv = NS_NewFileSpec(getter_AddRefs(cacheSubDir)) ;
+
+  for (int i=0; i < 32; i++) {
+    rv = cacheSubDir->FromFileSpec(m_pDiskCacheFolder) ;
+    if(NS_FAILED(rv))
+      return rv ;
+
+    char oldName[3], newName[8];
+    PR_snprintf(oldName, 3, "%0.2x", i) ;
+    cacheSubDir->AppendRelativeUnixPath(oldName) ;
+
+    // re-name the directory
+    PR_snprintf(newName, 8, "trash%0.2x", i) ;
+    rv = cacheSubDir->Rename(newName) ;
+    if(NS_FAILED(rv))
+      // TODO, error checking
+      return NS_ERROR_FAILURE ;
+  }
+
+  // update m_DBCorrupted 
+  m_DBCorrupted = PR_TRUE ;
+
+  return NS_OK ;
+}
+
+// this routine is used by dtor and RemoveAll() to clean up dirs.
+NS_IMETHODIMP
+nsNetDiskCache::RemoveFolder(nsFileSpec aFolder)
+{
+  for(nsDirectoryIterator di(aFolder, PR_FALSE); di.Exists(); di++) {
+    di.Spec().Delete(PR_TRUE) ;
+  }
+  
+  aFolder.Delete(PR_FALSE) ; // recursive delete
+  
+  return NS_OK ;
+}

mozilla/netwerk/cache/filecache/nsNetDiskCache.h

@@ -0,0 +1,91 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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 Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+/*
+ * This file is part of filecache implementation.
+ *
+ * nsNetDiskCache is the main disk cache module that will create 
+ * the cache database, and then store and retrieve nsDiskCacheRecord 
+ * objects from it. It also contains some basic error recovery procedure.
+ */
+
+#ifndef __gen_nsNetDiskCache_h__
+#define __gen_nsNetDiskCache_h__
+
+#include "nsINetDataDiskCache.h"
+#include "nsNetDiskCacheCID.h"
+#include "nsCOMPtr.h"
+#include "nsIPref.h"
+#include "nsDBAccessor.h"
+
+class nsIURI; /* forward decl */
+class nsICachedNetData; /* forward decl */
+class nsISimpleEnumerator; /* forward decl */
+class nsIFileSpec; /* forward decl */
+
+/* starting interface:    nsNetDiskCache */
+
+class nsNetDiskCache : public nsINetDataDiskCache {
+  public: 
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSINETDATACACHE
+  NS_DECL_NSINETDATADISKCACHE
+
+  NS_IMETHOD Init(void) ;
+
+  nsNetDiskCache() ;
+  virtual ~nsNetDiskCache() ;
+
+  protected:
+
+  NS_IMETHOD InitDB(void) ;
+  NS_IMETHOD CreateDir(nsIFileSpec* dir_spec) ;
+  NS_IMETHOD GetSpecialEntry(void) ;
+  NS_IMETHOD SetSpecialEntry(void) ;
+
+  NS_IMETHOD RenameCacheSubDirs(void) ;
+  NS_IMETHOD DBRecovery(void) ;
+  NS_IMETHOD RemoveFolder(nsFileSpec aFolder) ;
+
+  private:
+
+  PRBool 			                m_Enabled ;
+  PRUint32 			                m_NumEntries ;
+  nsCOMPtr<nsINetDataCache> 	    m_pNextCache ;
+  nsCOMPtr<nsIFileSpec>   	        m_pDiskCacheFolder ;
+  nsCOMPtr<nsIFileSpec>             m_DBFile ;
+
+  PRUint32                          m_MaxEntries ;
+  PRUint32                          m_StorageInUse ;
+  nsIDBAccessor*                    m_DB ;
+
+  // this is used to indicate a db corruption 
+  PRBool                            m_DBCorrupted ;
+
+  friend class nsDiskCacheRecord ;
+  friend class nsDiskCacheRecordChannel ;
+  friend class nsDBEnumerator ;
+} ;
+
+#endif /* __gen_nsNetDiskCache_h__ */

mozilla/netwerk/cache/filecache/nsNetDiskCacheCID.h

@@ -0,0 +1,32 @@
+/*
+ * 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 Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+#ifndef _nsNetDiskCacheCID_h_
+#define _nsNetDiskCacheCID_h_
+
+#define NS_NETDISKCACHE_CID_STR "ECFEEA00-7201-11d3-87FE-000629D01344"
+
+#define NS_NETDISKCACHE_CID \
+{ 0xecfeea00, 0x7201, 0x11d3, \
+ { 0x87, 0xfe, 0x0, 0x6, 0x29, 0xd0, 0x13, 0x44 }}
+
+#endif /* _nsNetDiskCacheCID_h_ */

mozilla/netwerk/cache/filecache/test/Makefile.in

@@ -0,0 +1,50 @@
+#
+# 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
+
+REQUIRES	= libreg xpcom
+
+CPPSRCS		= \
+         diskcache.cpp \
+		$(NULL)
+
+SIMPLE_PROGRAMS	= $(CPPSRCS:.cpp=)
+
+ifdef NO_LD_ARCHIVE_FLAGS
+LOST_SYM_LIBS	= -lxpcomds_s -lxptinfo -lmozreg_s
+endif
+
+LIBS		= \
+		-lmozjs \
+		-lxpcom \
+        -lmozdbm_s \
+		$(MOZ_NECKO_UTIL_LIBS) \
+		$(LOST_SYM_LIBS) \
+		$(NSPR_LIBS) \
+		$(NULL)
+
+include $(topsrcdir)/config/rules.mk
+
+LOCAL_INCLUDES = -I$(srcdir)/..
+
+DEFINES		+= -DUSE_NSREG -DCACHE

mozilla/netwerk/cache/filecache/test/diskcache.cpp

@@ -0,0 +1,836 @@
+/* -*- Mode: C++; tab-width: 2; 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 "nsIStreamListener.h"
+#include "nsIStreamObserver.h"
+#include "nsIServiceManager.h"
+#include "nsIInputStream.h"
+#include "nsIOutputStream.h"
+#include "nsIEventQueue.h"
+#include "nsIEventQueueService.h"
+#include "nsIChannel.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+#include <stdio.h>
+#include <unistd.h>
+
+#include "nsINetDataCache.h"
+#include "nsINetDataCacheRecord.h"
+//#include "nsMemCacheCID.h"
+#include "nsNetDiskCache.h"
+#include "nsIPref.h"
+#include "prenv.h"
+#include "nsIFileStream.h"
+
+// Number of test entries to be placed in the cache
+#define NUM_CACHE_ENTRIES  250
+
+// Cache content stream length will have random length between zero and
+// MAX_CONTENT_LENGTH bytes
+#define MAX_CONTENT_LENGTH 20000
+
+// Length of random-data cache entry key
+#define CACHE_KEY_LENGTH 15
+
+// Length of random-data cache entry meta-data
+#define CACHE_METADATA_LENGTH 100
+
+//static NS_DEFINE_CID(kMemCacheCID, NS_MEM_CACHE_FACTORY_CID);
+static NS_DEFINE_CID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID);
+static NS_DEFINE_CID(kDiskCacheCID, NS_NETDISKCACHE_CID) ;
+static NS_DEFINE_CID(kPrefCID, NS_PREF_CID);
+static NS_DEFINE_IID(kIPrefIID, NS_IPREF_IID);
+
+// Mapping from test case number to RecordID
+static PRInt32 recordID[NUM_CACHE_ENTRIES];
+
+static PRInt32
+mapRecordIdToTestNum(PRInt32 aRecordID)
+{
+    int i;
+    for (i = 0; i < NUM_CACHE_ENTRIES; i++) {
+        if (recordID[i] == aRecordID)
+            return i;
+    }
+    return -1;
+}
+
+// A supply of stream data to either store or compare with
+class nsITestDataStream {
+public:
+    virtual ~nsITestDataStream() {};
+    virtual PRUint32 Next() = 0;
+    virtual void Read(char* aBuf, PRUint32 aCount) = 0;
+
+    virtual PRBool Match(char* aBuf, PRUint32 aCount) = 0;
+    virtual void Skip(PRUint32 aCount) = 0;
+};
+
+// A reproducible stream of random data.
+class RandomStream : public nsITestDataStream {
+public:
+    RandomStream(PRUint32 aSeed) {
+        mStartSeed = mState = aSeed;
+    }
+    
+    PRUint32 GetStartSeed() {
+        return mStartSeed;
+    }
+    
+    PRUint32 Next() {
+        mState = 1103515245 * mState + 12345;
+        return mState;
+    }
+
+    void Read(char* aBuf, PRUint32 aCount) {
+        PRUint32 i;
+        for (i = 0; i < aCount; i++) {
+            *aBuf++ = Next();
+        }
+    }
+
+    PRBool
+    Match(char* aBuf, PRUint32 aCount) {
+        PRUint32 i;
+        for (i = 0; i < aCount; i++) {
+            if (*aBuf++ != (char)(Next() & 0xff))
+                return PR_FALSE;
+        }
+        return PR_TRUE;
+    }
+
+    void
+    Skip(PRUint32 aCount) {
+        while (aCount--)
+            Next();
+    }
+
+protected:
+    
+    PRUint32 mState;
+    PRUint32 mStartSeed;
+};
+
+// A stream of data that increments on each byte that is read, modulo 256
+class CounterStream : public nsITestDataStream {
+public:
+    CounterStream(PRUint32 aSeed) {
+        mStartSeed = mState = aSeed;
+    }
+    
+    PRUint32 GetStartSeed() {
+        return mStartSeed;
+    }
+    
+    PRUint32 Next() {
+        mState += 1;
+        mState &= 0xff;
+        return mState;
+    }
+
+    void Read(char* aBuf, PRUint32 aCount) {
+        PRUint32 i;
+        for (i = 0; i < aCount; i++) {
+            *aBuf++ = Next();
+        }
+    }
+
+    PRBool
+    Match(char* aBuf, PRUint32 aCount) {
+        PRUint32 i;
+        for (i = 0; i < aCount; i++) {
+            if (*aBuf++ != (char)Next())
+                return PR_FALSE;
+        }
+        return PR_TRUE;
+    }
+
+    void
+    Skip(PRUint32 aCount) {
+        mState += aCount;
+        mState &= 0xff;
+    }
+
+protected:
+    
+    PRUint32 mState;
+    PRUint32 mStartSeed;
+};
+
+static int gNumReaders = 0;
+static PRUint32 gTotalBytesRead = 0;
+static PRUint32 gTotalDuration = 0;
+
+class nsReader : public nsIStreamListener {
+public:
+    NS_DECL_ISUPPORTS
+
+    nsReader()
+        : mStartTime(0), mBytesRead(0)
+    {
+        NS_INIT_REFCNT();
+        gNumReaders++;
+    }
+
+    virtual ~nsReader() {
+        delete mTestDataStream;
+        gNumReaders--;
+    }
+
+    nsresult 
+    Init(nsIChannel *aChannel, nsITestDataStream* aRandomStream, PRUint32 aExpectedStreamLength) {
+        mChannel = aChannel;
+        mTestDataStream = aRandomStream;
+        mExpectedStreamLength = aExpectedStreamLength;
+        mRefCnt = 1;
+        return NS_OK;
+    }
+
+    NS_IMETHOD OnStartRequest(nsIChannel* channel,
+                              nsISupports* context) {
+        mStartTime = PR_IntervalNow();
+        return NS_OK;
+    }
+
+    NS_IMETHOD OnDataAvailable(nsIChannel* channel, 
+                               nsISupports* context,
+                               nsIInputStream *aIStream, 
+                               PRUint32 aSourceOffset,
+                               PRUint32 aLength) {
+        char buf[1025];
+        while (aLength > 0) {
+            PRUint32 amt;
+            PRBool match;
+            aIStream->Read(buf, sizeof buf, &amt);
+            if (amt == 0) break;
+            aLength -= amt;
+            mBytesRead += amt;
+            match = mTestDataStream->Match(buf, amt);
+            NS_ASSERTION(match, "Stored data was corrupted on read");
+        }
+        return NS_OK;
+    }
+
+    NS_IMETHOD OnStopRequest(nsIChannel* channel, 
+                             nsISupports* context,
+                             nsresult aStatus,
+                             const PRUnichar* aMsg) {
+        PRIntervalTime endTime;
+        PRIntervalTime duration;
+        
+        endTime = PR_IntervalNow();
+        duration = (endTime - mStartTime);
+
+        if (NS_FAILED(aStatus)) printf("channel failed.\n");
+        //        printf("read %d bytes\n", mBytesRead);
+
+        NS_ASSERTION(mBytesRead == mExpectedStreamLength,
+                     "Stream in cache is wrong length");
+
+        gTotalBytesRead += mBytesRead;
+        gTotalDuration += duration;
+
+        // Release channel
+        mChannel = 0;
+        return NS_OK;
+    }
+
+protected:
+    PRIntervalTime       mStartTime;
+    PRUint32             mBytesRead;
+    nsITestDataStream*   mTestDataStream;
+    PRUint32             mExpectedStreamLength;
+    nsCOMPtr<nsIChannel> mChannel;
+};
+
+NS_IMPL_ISUPPORTS2(nsReader, nsIStreamListener, nsIStreamObserver)
+
+static nsIEventQueue* eventQueue;
+
+nsresult
+InitQueue() {
+    nsresult rv;
+
+    NS_WITH_SERVICE(nsIEventQueueService, eventQService, kEventQueueServiceCID, &rv);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get event queue service");
+
+    rv = eventQService->CreateThreadEventQueue();
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't create event queue");
+  
+    rv = eventQService->GetThreadEventQueue(PR_CurrentThread(), &eventQueue);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get event queue for main thread");
+
+    return NS_OK;
+}
+
+// Process events until all streams are OnStopRequest'ed
+nsresult
+WaitForEvents() {
+    while (gNumReaders) {
+        eventQueue->ProcessPendingEvents();
+    }
+    return NS_OK;
+}
+
+// Read data for a single cache record and compare against testDataStream
+nsresult
+TestReadStream(nsINetDataCacheRecord *record, nsITestDataStream *testDataStream,
+               PRUint32 expectedStreamLength)
+{
+    nsCOMPtr<nsIChannel> channel;
+    nsresult rv;
+    PRUint32 actualContentLength;
+
+    rv = record->NewChannel(0, getter_AddRefs(channel));
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+    rv = record->GetStoredContentLength(&actualContentLength);
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+    NS_ASSERTION(actualContentLength == expectedStreamLength,
+                 "nsINetDataCacheRecord::GetContentLength() busted ?");
+    
+    nsReader *reader = new nsReader;
+    reader->AddRef();
+    rv = reader->Init(channel, testDataStream, expectedStreamLength);
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+    
+    rv = channel->AsyncRead(0, -1, 0, reader);
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+    reader->Release();
+
+    return NS_OK;
+}
+
+// Check that records can be retrieved using their record-ID, in addition
+// to using the opaque key.
+nsresult
+TestRecordID(nsINetDataCache *cache)
+{
+    nsresult rv;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    RandomStream *randomStream;
+    PRUint32 metaDataLength;
+    char cacheKey[CACHE_KEY_LENGTH];
+    char *metaData;
+    PRUint32 testNum;
+    PRBool match;
+
+    for (testNum = 0; testNum < NUM_CACHE_ENTRIES; testNum++) {
+        randomStream = new RandomStream(testNum);
+        randomStream->Read(cacheKey, sizeof cacheKey);
+
+        rv = cache->GetCachedNetDataByID(recordID[testNum], getter_AddRefs(record));
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't obtain record using record ID");
+
+        // Match against previously stored meta-data
+        rv = record->GetMetaData(&metaDataLength, &metaData);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get record meta-data");
+        match = randomStream->Match(metaData, metaDataLength);
+        NS_ASSERTION(match, "Meta-data corrupted or incorrect");
+
+        nsAllocator::Free(metaData);
+        delete randomStream;
+    }
+    return NS_OK;
+}
+
+// Check that all cache entries in the database are enumerated and that
+// no duplicates appear.
+nsresult
+TestEnumeration(nsINetDataCache *cache)
+{
+    nsresult rv;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    nsCOMPtr<nsISupports> tempISupports;
+    nsCOMPtr<nsISimpleEnumerator> iterator;
+    RandomStream *randomStream;
+    PRUint32 metaDataLength;
+    char cacheKey[CACHE_KEY_LENGTH];
+    char *metaData;
+    PRUint32 testNum;
+    PRBool match;
+    PRInt32 recID;
+
+    int numRecords = 0;
+
+    // Iterate over all records in the cache
+    rv = cache->NewCacheEntryIterator(getter_AddRefs(iterator));
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't create new cache entry iterator");
+
+    PRBool notDone;
+    while (1) {
+
+        // Done iterating ?
+        rv = iterator->HasMoreElements(&notDone);
+        if (NS_FAILED(rv)) return rv;
+        if (!notDone)
+            break;
+
+        // Get next record in iteration
+        rv = iterator->GetNext(getter_AddRefs(tempISupports));
+        NS_ASSERTION(NS_SUCCEEDED(rv), "iterator bustage");
+        record = do_QueryInterface(tempISupports);
+
+        numRecords++;
+
+        // Get record ID
+        rv = record->GetRecordID(&recID);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get Record ID");
+        testNum = mapRecordIdToTestNum(recID);
+        NS_ASSERTION(testNum != -1, "Corrupted Record ID ?");
+
+        // Erase mapping from table, so that duplicate enumerations are detected
+        recordID[testNum] = -1;
+
+        // Make sure stream matches test data
+        randomStream = new RandomStream(testNum);
+        randomStream->Read(cacheKey, sizeof cacheKey);
+
+        // Match against previously stored meta-data
+        rv = record->GetMetaData(&metaDataLength, &metaData);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get record meta-data");
+        match = randomStream->Match(metaData, metaDataLength);
+        NS_ASSERTION(match, "Meta-data corrupted or incorrect");
+        nsAllocator::Free(metaData);
+
+        delete randomStream;
+    }
+
+    NS_ASSERTION(numRecords == NUM_CACHE_ENTRIES, "Iteration bug");
+
+    return NS_OK;
+}
+
+// Read the test data that was written in FillCache(), checking for
+// corruption, truncation.
+nsresult
+TestRead(nsINetDataCache *cache)
+{
+    nsresult rv;
+    PRBool inCache;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    RandomStream *randomStream;
+    PRUint32 metaDataLength;
+    char cacheKey[CACHE_KEY_LENGTH];
+    char *metaData, *storedCacheKey;
+    PRUint32 testNum, storedCacheKeyLength;
+    PRBool match;
+
+    for (testNum = 0; testNum < NUM_CACHE_ENTRIES; testNum++) {
+        randomStream = new RandomStream(testNum);
+        randomStream->Read(cacheKey, sizeof cacheKey);
+
+        // Ensure that entry is in the cache
+        rv = cache->Contains(cacheKey, sizeof cacheKey, &inCache);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        NS_ASSERTION(inCache, "nsINetDataCache::Contains error");
+        
+        rv = cache->GetCachedNetData(cacheKey, sizeof cacheKey, getter_AddRefs(record));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+        // Match against previously stored meta-data
+        match = record->GetMetaData(&metaDataLength, &metaData);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        match = randomStream->Match(metaData, metaDataLength);
+        NS_ASSERTION(match, "Meta-data corrupted or incorrect");
+        nsAllocator::Free(metaData);
+
+        // Test GetKey() method
+        rv = record->GetKey(&storedCacheKeyLength, &storedCacheKey);
+        NS_ASSERTION(NS_SUCCEEDED(rv) &&
+                     (storedCacheKeyLength == sizeof cacheKey) &&
+                     !memcmp(storedCacheKey, &cacheKey[0], sizeof cacheKey),
+                     "nsINetDataCacheRecord::GetKey failed");
+        nsAllocator::Free(storedCacheKey);
+
+        PRUint32 expectedStreamLength = randomStream->Next() & 0xffff;
+
+        TestReadStream(record, randomStream, expectedStreamLength);
+    }
+
+    WaitForEvents();
+
+    // Compute rate in MB/s
+    double rate = gTotalBytesRead / PR_IntervalToMilliseconds(gTotalDuration);
+    rate *= NUM_CACHE_ENTRIES;
+    rate *= 1000;
+    rate /= (1024 * 1024);
+    printf("Read %d bytes at a rate of %5.1f MB per second \n",
+           gTotalBytesRead, rate);
+
+    return NS_OK;
+}
+
+// Repeatedly call SetStoredContentLength() on a cache entry and make
+// read the stream's data to ensure that it's not corrupted by the effect
+nsresult
+TestTruncation(nsINetDataCache *cache)
+{
+    nsresult rv;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    RandomStream *randomStream;
+    char cacheKey[CACHE_KEY_LENGTH];
+
+    randomStream = new RandomStream(0);
+    randomStream->Read(cacheKey, sizeof cacheKey);
+
+    rv = cache->GetCachedNetData(cacheKey, sizeof cacheKey, getter_AddRefs(record));
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+    randomStream->Skip(CACHE_METADATA_LENGTH);
+    PRUint32 initialStreamLength = randomStream->Next() & 0xffff;
+    delete randomStream;
+
+    PRUint32 i;
+    PRUint32 delta = initialStreamLength / 64;
+    for (i = initialStreamLength; i >= delta; i -= delta) {
+        PRUint32 expectedStreamLength = i;
+
+        // Do the truncation
+        record->SetStoredContentLength(expectedStreamLength);
+        randomStream = new RandomStream(0);
+        randomStream->Skip(CACHE_KEY_LENGTH + CACHE_METADATA_LENGTH + 1);
+
+        TestReadStream(record, randomStream, expectedStreamLength);
+        WaitForEvents();
+    }
+
+    return NS_OK;
+}
+
+// Write known data to random offsets in a single cache entry and test
+// resulting stream for correctness.
+nsresult
+TestOffsetWrites(nsINetDataCache *cache)
+{
+    nsresult rv;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    nsCOMPtr<nsIChannel> channel;
+    nsCOMPtr<nsIOutputStream> outStream;
+    char buf[512];
+    char cacheKey[CACHE_KEY_LENGTH];
+    RandomStream *randomStream;
+
+    randomStream = new RandomStream(0);
+    randomStream->Read(cacheKey, sizeof cacheKey);
+
+    rv = cache->GetCachedNetData(cacheKey, sizeof cacheKey, getter_AddRefs(record));
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't access record via opaque cache key");
+
+
+    nsCOMPtr<nsIFileSpec> file ;
+    record->GetFilename(getter_AddRefs(file)) ;
+    char* name ;
+    file->GetUnixStyleFilePath(&name) ;
+    printf(" file name is %s \n", name) ;
+
+    // Write buffer-fulls of data at random offsets into the cache entry.
+    // Data written is (offset % 0xff)
+    PRUint32 startingOffset;
+    PRUint32 streamLength = 0;
+    PRUint32 len = 0 ;
+    CounterStream *counterStream;
+
+    int i = 0;
+    for (i = 0; i < 257; i++) {
+        rv = record->NewChannel(0, getter_AddRefs(channel));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+        startingOffset = streamLength ? streamLength - (randomStream->Next() % sizeof buf): 0;
+        rv = channel->OpenOutputStream(startingOffset, getter_AddRefs(outStream));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        
+        truncate(name, startingOffset) ;
+
+        counterStream = new CounterStream(startingOffset);
+        counterStream->Read(buf, sizeof buf);
+
+      nsresult status ;
+      nsCOMPtr<nsIRandomAccessStore> ras = do_QueryInterface(outStream, &status);
+      if (NS_FAILED(status)) {
+      //        mState = END_WRITE;
+        return NS_ERROR_FAILURE;
+      }
+      PRIntn offset ;
+      ras->Tell(&offset) ;
+//      printf(" offset is %d \n", offset) ;
+
+        PRUint32 numWritten;
+        rv = outStream->Write(buf, sizeof buf, &numWritten);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        NS_ASSERTION(numWritten == sizeof buf, "Write() bug?");
+        streamLength = startingOffset + sizeof buf;
+
+        rv = outStream->Close();
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't close channel");
+        delete counterStream;
+
+        record->GetStoredContentLength(&len) ;
+        if(len != streamLength) 
+          printf(" offset = %d is wrong, filesize = %d\n", startingOffset, len) ;
+
+    }
+
+        /*
+        rv = record->NewChannel(0, getter_AddRefs(channel));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+        startingOffset = 208;
+        rv = channel->OpenOutputStream(startingOffset, getter_AddRefs(outStream));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        
+        counterStream = new CounterStream(startingOffset);
+        counterStream->Read(buf, sizeof buf);
+
+      nsresult status ;
+      nsCOMPtr<nsIRandomAccessStore> ras = do_QueryInterface(outStream, &status);
+      if (NS_FAILED(status)) {
+      //        mState = END_WRITE;
+        return NS_ERROR_FAILURE;
+      }
+      PRIntn offset = 0 ;
+      ras->Tell(&offset) ;
+      printf(" offset is %d \n", offset) ;
+
+        PRUint32 numWritten;
+        rv = outStream->Write(buf, sizeof buf, &numWritten);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        NS_ASSERTION(numWritten == sizeof buf, "Write() bug?");
+        streamLength = startingOffset + sizeof buf;
+
+        rv = outStream->Close();
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't close channel");
+        delete counterStream;
+
+        record->GetStoredContentLength(&len) ;
+        if(len != streamLength) 
+          printf(" offset = %d is wrong, filesize = %d\n", startingOffset, len) ;
+          */
+    
+    delete randomStream;
+
+    counterStream = new CounterStream(0);
+    TestReadStream(record, counterStream, streamLength);
+    WaitForEvents();
+
+    return NS_OK;
+}
+
+// Create entries in the network data cache, using random data for the
+// key, the meta-data and the stored content data.
+nsresult
+FillCache(nsINetDataCache *cache)
+{
+    nsresult rv;
+    PRBool inCache;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    nsCOMPtr<nsIChannel> channel;
+    nsCOMPtr<nsIOutputStream> outStream;
+    char buf[1000];
+    PRUint32 metaDataLength;
+    char cacheKey[CACHE_KEY_LENGTH];
+    char metaData[CACHE_METADATA_LENGTH];
+    PRUint32 testNum;
+    char *data;
+    RandomStream *randomStream;
+
+    PRIntervalTime startTime = PR_IntervalNow();
+    
+    for (testNum = 0; testNum < NUM_CACHE_ENTRIES; testNum++) {
+        randomStream = new RandomStream(testNum);
+        randomStream->Read(cacheKey, sizeof cacheKey);
+
+        // No entry should be in cache until we add it
+        rv = cache->Contains(cacheKey, sizeof cacheKey, &inCache);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        NS_ASSERTION(!inCache, "nsINetDataCache::Contains error");
+        
+        rv = cache->GetCachedNetData(cacheKey, sizeof cacheKey, getter_AddRefs(record));
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't access record via opaque cache key");
+
+        // Test nsINetDataCacheRecord::GetRecordID()
+        rv = record->GetRecordID(&recordID[testNum]);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get Record ID");
+
+        // Test nsINetDataCache::GetNumEntries()
+        PRUint32 numEntries = (PRUint32)-1;
+        rv = cache->GetNumEntries(&numEntries);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get number of cache entries");
+        NS_ASSERTION(numEntries == testNum + 1, "GetNumEntries failure");
+
+        // Record meta-data should be initially empty
+        rv = record->GetMetaData(&metaDataLength, &data);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        if ((metaDataLength != 0) || (data != 0))
+            return NS_ERROR_FAILURE;
+
+        // Store random data as meta-data
+        randomStream->Read(metaData, sizeof metaData);
+        record->SetMetaData(sizeof metaData, metaData);
+
+        rv = record->NewChannel(0, getter_AddRefs(channel));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+        rv = channel->OpenOutputStream(0, getter_AddRefs(outStream));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        
+        PRUint32 beforeOccupancy;
+        rv = cache->GetStorageInUse(&beforeOccupancy);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get cache occupancy");
+
+        int streamLength = randomStream->Next() & 0xffff;
+        int remaining = streamLength;
+        while (remaining) {
+            PRUint32 numWritten;
+            int amount = PR_MIN(sizeof buf, remaining);
+            randomStream->Read(buf, amount);
+
+            rv = outStream->Write(buf, amount, &numWritten);
+            NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+            NS_ASSERTION(numWritten == (PRUint32)amount, "Write() bug?");
+            
+            remaining -= amount;
+        }
+        outStream->Close();
+
+        PRUint32 afterOccupancy;
+        rv = cache->GetStorageInUse(&afterOccupancy);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get cache occupancy");
+        PRUint32 streamLengthInKB = streamLength >> 10;
+        NS_ASSERTION((afterOccupancy - beforeOccupancy) >= streamLengthInKB,
+                     "nsINetDataCache::GetStorageInUse() is busted");
+        
+
+        // *Now* there should be an entry in the cache
+        rv = cache->Contains(cacheKey, sizeof cacheKey, &inCache);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        NS_ASSERTION(inCache, "nsINetDataCache::Contains error");
+
+        delete randomStream;
+    }
+
+    PRIntervalTime endTime = PR_IntervalNow();
+
+    return NS_OK;
+}
+
+nsresult NS_AutoregisterComponents()
+{
+  nsresult rv = nsComponentManager::AutoRegister(nsIComponentManager::NS_Startup,
+                                                 NULL /* default */);
+  return rv;
+}
+
+PRBool initPref ()
+{
+  nsresult rv;
+  NS_WITH_SERVICE(nsIPref, prefPtr, kPrefCID, &rv);
+  if (NS_FAILED(rv))
+    return false;
+
+  nsCOMPtr<nsIFileSpec> fileSpec;
+  rv = NS_NewFileSpec (getter_AddRefs(fileSpec));
+  if (NS_FAILED(rv))
+    return false;
+
+  nsCString defaultPrefFile = PR_GetEnv ("MOZILLA_FIVE_HOME");
+  if (defaultPrefFile.Length())
+    defaultPrefFile += "/";
+  else
+    defaultPrefFile = "./";
+  defaultPrefFile += "default_prefs.js";
+
+  fileSpec->SetUnixStyleFilePath (defaultPrefFile.GetBuffer());
+
+  PRBool exists = false;
+  fileSpec->Exists(&exists);
+  if (exists)
+    prefPtr->ReadUserPrefsFrom(fileSpec);
+  else
+    return false;
+  return true;
+}
+
+int
+main(int argc, char* argv[])
+{
+    initPref() ;
+    nsresult rv;
+    nsCOMPtr<nsINetDataCache> cache;
+
+    rv = NS_AutoregisterComponents();
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't register XPCOM components");
+
+    rv = nsComponentManager::CreateInstance(kDiskCacheCID, nsnull,
+                                            NS_GET_IID(nsINetDataCache),
+                                            getter_AddRefs(cache));
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't create memory cache factory");
+
+    InitQueue();
+
+    PRUnichar* description;
+    rv = cache->GetDescription(&description);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get cache description");
+    nsCAutoString descStr(description);
+    printf("Testing: %s\n", descStr.GetBuffer());
+
+    rv = cache->RemoveAll();
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't clear cache");
+
+    PRUint32 startOccupancy;
+    rv = cache->GetStorageInUse(&startOccupancy);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get cache occupancy");
+
+    PRUint32 numEntries = (PRUint32)-1;
+    rv = cache->GetNumEntries(&numEntries);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get number of cache entries");
+    NS_ASSERTION(numEntries == 0, "Couldn't clear cache");
+
+    rv = FillCache(cache);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't fill cache with random test data");
+
+    rv = TestRead(cache);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't read random test data from cache");
+
+    rv = TestRecordID(cache);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't index records using record ID");
+
+    rv = TestEnumeration(cache);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't successfully enumerate records");
+
+    rv = TestTruncation(cache);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't successfully truncate records");
+
+    rv = TestOffsetWrites(cache);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't successfully write to records using non-zero offsets");
+
+    rv = cache->RemoveAll();
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't clear cache");
+    rv = cache->GetNumEntries(&numEntries);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get number of cache entries");
+    NS_ASSERTION(numEntries == 0, "Couldn't clear cache");
+
+    PRUint32 endOccupancy;
+    rv = cache->GetStorageInUse(&endOccupancy);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get cache occupancy");
+
+    NS_ASSERTION(startOccupancy == endOccupancy, "Cache occupancy not correctly computed ?");
+
+    return 0;
+}
+

mozilla/netwerk/cache/memcache/Makefile.in

@@ -0,0 +1,48 @@
+# Generated automatically from Makefile.in by configure.
+#
+# 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@
+VPATH       = @srcdir@
+srcdir		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE = nkcache
+
+LIBRARY_NAME = nkmemcache_s
+
+REQUIRES	= nspr dbm 
+
+EXPORTS=nsMemCacheCID.h \
+	nsMemCache.h \
+	$(NULL)
+
+CPPSRCS		= \
+        nsMemCache.cpp \
+        nsMemCacheRecord.cpp \
+        nsMemCacheChannel.cpp \
+		$(NULL)
+
+# we don't want the shared lib, but we want to force the creation of a
+# static lib.
+override NO_SHARED_LIB=1
+override NO_STATIC_LIB=
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/netwerk/cache/memcache/makefile.win

@@ -0,0 +1,42 @@
+#!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=..\..\..
+
+include <$(DEPTH)/config/config.mak>
+
+MODULE = nkcache
+
+LIBRARY_NAME = nkmemcache_s
+
+CPP_OBJS =                                \
+ 	.\$(OBJDIR)\nsMemCache.obj        \
+	.\$(OBJDIR)\nsMemCacheRecord.obj  \
+	.\$(OBJDIR)\nsMemCacheChannel.obj \
+	$(NULL)
+
+EXPORTS=nsMemCacheCID.h
+
+include <$(DEPTH)\config\rules.mak>
+
+install:: $(LIBRARY)
+	$(MAKE_INSTALL) $(LIBRARY) $(DIST)\lib
+
+clobber::
+        rm -rf $(OBJDIR)
+        rm -f $(DIST)\lib\$(LIBRARY_NAME).lib
+

mozilla/netwerk/cache/memcache/nsMemCache.cpp

@@ -0,0 +1,334 @@
+/* -*- 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.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 Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ */
+
+/**
+ * nsMemCache is the implementation of an in-memory network-data
+ * cache, used to cache the responses to network retrieval commands.
+ * Each cache entry may contain both content, e.g. GIF image data, and
+ * associated metadata, e.g. HTTP headers.  Each entry is indexed by
+ * two different keys: a record id number and an opaque key, which is
+ * created by the cache manager by combining the URI with a "secondary
+ * key", e.g. HTTP post data.
+ */
+
+#include "nsMemCache.h"
+#include "nsMemCacheRecord.h"
+#include "nsIGenericFactory.h"
+#include "nsString.h"
+#include "nsHashtable.h"
+#include "nsHashtableEnumerator.h"
+#include "nsEnumeratorUtils.h"
+
+PRInt32 nsMemCache::gRecordSerialNumber = 0;
+
+nsMemCache::nsMemCache()
+    : mNumEntries(0), mOccupancy(0), mEnabled(PR_TRUE),
+      mHashTable(0)
+{
+    NS_INIT_REFCNT();
+}
+
+nsMemCache::~nsMemCache()
+{
+    nsresult rv;
+
+    rv = RemoveAll();
+    NS_ASSERTION(NS_SUCCEEDED(rv) && (mNumEntries == 0),
+                 "Failure to shut down memory cache. "
+                 "Somewhere, someone is holding references to at least one cache record");
+    delete mHashTable;
+}
+
+nsresult
+nsMemCache::Init()
+{
+    mHashTable = new nsHashtable(256);
+    if (!mHashTable)
+        return NS_ERROR_OUT_OF_MEMORY;
+    return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(nsMemCache, NS_GET_IID(nsINetDataCache))
+
+NS_IMETHODIMP
+nsMemCache::GetDescription(PRUnichar * *aDescription)
+{
+    nsAutoString description("Memory Cache");
+    *aDescription = description.ToNewUnicode();
+    if (!*aDescription)
+        return NS_ERROR_OUT_OF_MEMORY;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::Contains(const char *aKey, PRUint32 aKeyLength, PRBool *aFound)
+{
+    nsOpaqueKey *opaqueKey = new nsOpaqueKey(aKey, aKeyLength);
+    if (!opaqueKey)
+        return NS_ERROR_OUT_OF_MEMORY;
+    *aFound = mHashTable->Exists(opaqueKey);
+    delete opaqueKey;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::GetCachedNetData(const char *aKey, PRUint32 aKeyLength,
+                             nsINetDataCacheRecord* *aRecord)
+{
+    nsresult rv;
+    nsMemCacheRecord* record = 0;
+    nsOpaqueKey *opaqueKey2 = 0;
+    nsOpaqueKey *opaqueKey3 = 0;
+    nsOpaqueKey *opaqueKey;
+
+    opaqueKey = new nsOpaqueKey(aKey, aKeyLength);
+    if (!opaqueKey)
+        goto out_of_memory;
+    record = (nsMemCacheRecord*)mHashTable->Get(opaqueKey);
+    delete opaqueKey;
+
+    // No existing cache database entry was found.  Create a new one.
+    // This requires two mappings in the hash table:
+    //    Record ID  ==> record
+    //    Opaque key ==> record
+    if (!record) {
+        record = new nsMemCacheRecord;
+        if (!record)
+            goto out_of_memory;
+        rv = record->Init(aKey, aKeyLength, ++gRecordSerialNumber, this);
+        if (NS_FAILED(rv)) goto out_of_memory;
+
+        // Index the record by opaque key
+        opaqueKey2 = new nsOpaqueKey(record->mKey, record->mKeyLength);
+        if (!opaqueKey2) goto out_of_memory;
+        mHashTable->Put(opaqueKey2, record);
+        
+        // Index the record by it's record ID
+        char *recordIDbytes = NS_REINTERPRET_CAST(char *, &record->mRecordID);
+        opaqueKey3 = new nsOpaqueKey(recordIDbytes,
+                                     sizeof record->mRecordID);
+        if (!opaqueKey3) {
+            // Clean up the first record from the hash table
+            mHashTable->Remove(opaqueKey);
+            goto out_of_memory;
+        }
+        mHashTable->Put(opaqueKey3, record);
+        
+        // The hash table holds on to the record
+        record->AddRef();
+        
+        delete opaqueKey2;
+        delete opaqueKey3;
+        mNumEntries++;
+    }
+
+    record->AddRef();
+    *aRecord = record;
+    return NS_OK;
+
+ out_of_memory:
+    delete opaqueKey2;
+    delete opaqueKey3;
+    delete record;
+    return NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsMemCache::GetCachedNetDataByID(PRInt32 RecordID,
+                                 nsINetDataCacheRecord* *aRecord)
+{
+    nsOpaqueKey opaqueKey(NS_REINTERPRET_CAST(const char *, &RecordID),
+                          sizeof RecordID);
+    *aRecord = (nsINetDataCacheRecord*)mHashTable->Get(&opaqueKey);
+    if (*aRecord) {
+        NS_ADDREF(*aRecord);
+        return NS_OK;
+    }
+    return NS_ERROR_FAILURE;
+}
+
+NS_METHOD
+nsMemCache::Delete(nsMemCacheRecord* aRecord)
+{
+    nsMemCacheRecord *removedRecord;
+
+    char *recordIDbytes = NS_REINTERPRET_CAST(char *, &aRecord->mRecordID);
+    nsOpaqueKey opaqueRecordIDKey(recordIDbytes,
+                                  sizeof aRecord->mRecordID);
+    removedRecord = (nsMemCacheRecord*)mHashTable->Remove(&opaqueRecordIDKey);
+    NS_ASSERTION(removedRecord == aRecord, "memory cache database inconsistent");
+
+    nsOpaqueKey opaqueKey(aRecord->mKey, aRecord->mKeyLength);
+    removedRecord = (nsMemCacheRecord*)mHashTable->Remove(&opaqueKey);
+    NS_ASSERTION(removedRecord == aRecord, "memory cache database inconsistent");
+
+    aRecord->Release();
+
+    mNumEntries--;
+    
+    return NS_OK;
+}
+    
+
+NS_IMETHODIMP
+nsMemCache::GetEnabled(PRBool *aEnabled)
+{
+    NS_ENSURE_ARG(aEnabled);
+    *aEnabled = mEnabled;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::SetEnabled(PRBool aEnabled)
+{
+    mEnabled = aEnabled;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::GetFlags(PRUint32 *aFlags)
+{
+    NS_ENSURE_ARG(aFlags);
+    *aFlags = MEMORY_CACHE;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::GetNumEntries(PRUint32 *aNumEntries)
+{
+    NS_ENSURE_ARG(aNumEntries);
+    *aNumEntries = mNumEntries;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::GetMaxEntries(PRUint32 *aMaxEntries)
+{
+    NS_ENSURE_ARG(aMaxEntries);
+    *aMaxEntries = MEM_CACHE_MAX_ENTRIES;
+    return NS_OK;
+}
+
+static NS_METHOD
+HashEntryConverter(nsHashKey *aKey, void *aValue,
+                   void *unused, nsISupports **retval)
+{
+    nsMemCacheRecord *record;
+    nsOpaqueKey *opaqueKey;
+
+    record = (nsMemCacheRecord*)aValue;
+    opaqueKey = (nsOpaqueKey*)aKey;
+
+    // Hash table keys that index cache entries by their record ID
+    // shouldn't be enumerated.
+    if ((opaqueKey->GetKeyLength() == sizeof(PRInt32))) {
+
+#ifdef DEBUG
+        PRInt32 recordID;
+        record->GetRecordID(&recordID);
+        NS_ASSERTION(*((PRInt32*)opaqueKey->GetKey()) == recordID,
+                     "Key has incorrect key length");
+#endif
+        return NS_ERROR_FAILURE;
+    }
+
+    NS_IF_ADDREF(record);
+    *retval = NS_STATIC_CAST(nsISupports*, record);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::NewCacheEntryIterator(nsISimpleEnumerator* *aIterator)
+{
+    nsCOMPtr<nsIEnumerator> iterator;
+
+    NS_ENSURE_ARG(aIterator);
+    NS_NewHashtableEnumerator(mHashTable, HashEntryConverter,
+                              mHashTable, getter_AddRefs(iterator));
+    return NS_NewAdapterEnumerator(aIterator, iterator);
+}
+
+NS_IMETHODIMP
+nsMemCache::GetNextCache(nsINetDataCache* *aNextCache)
+{
+    NS_ENSURE_ARG(aNextCache);
+    *aNextCache = mNextCache;
+    NS_ADDREF(*aNextCache);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::SetNextCache(nsINetDataCache* aNextCache)
+{
+    mNextCache = aNextCache;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::GetStorageInUse(PRUint32 *aStorageInUse)
+{
+    NS_ENSURE_ARG(aStorageInUse);
+
+    // Convert from bytes to KB
+    *aStorageInUse = (mOccupancy >> 10);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::RemoveAll(void)
+{
+    PRBool failed;
+
+    nsCOMPtr<nsISimpleEnumerator> iterator;
+    nsCOMPtr<nsISupports> recordSupports;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    nsresult rv;
+
+    failed = PR_FALSE;
+    rv = NewCacheEntryIterator(getter_AddRefs(iterator));
+    if (NS_FAILED(rv))
+        return rv;
+
+    PRBool notDone;
+    while (1) {
+        rv = iterator->HasMoreElements(&notDone);
+        if (NS_FAILED(rv)) return rv;
+        if (!notDone)
+            break;
+        
+        iterator->GetNext(getter_AddRefs(recordSupports));
+        record = do_QueryInterface(recordSupports);
+        recordSupports = 0;
+
+        PRUint32 bytesUsed;
+        record->GetStoredContentLength(&bytesUsed);
+        rv = record->Delete();
+        if (NS_FAILED(rv)) {
+            failed = PR_TRUE;
+            continue;
+        }
+        mOccupancy -= bytesUsed;
+    }
+
+    if (failed)
+        return NS_ERROR_FAILURE;
+    return NS_OK;
+}

mozilla/netwerk/cache/memcache/nsMemCache.h

@@ -0,0 +1,83 @@
+/* -*- 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.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 Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ */
+
+/**
+ * nsMemCache is the implementation of an in-memory network-data
+ * cache, used to cache the responses to network retrieval commands.
+ * Each cache entry may contain both content, e.g. GIF image data, and
+ * associated metadata, e.g. HTTP headers.  Each entry is indexed by
+ * two different keys: a record id number and an opaque key, which is
+ * created by the cache manager by combining the URI with a "secondary
+ * key", e.g. HTTP post data.
+ */
+
+#ifndef _nsMemCache_h_
+#define _nsMemCache_h_
+
+#include "nsINetDataCache.h"
+
+// Maximum number of URIs that may be resident in the cache
+#define MEM_CACHE_MAX_ENTRIES 1000
+
+#define MEM_CACHE_SEGMENT_SIZE       (1 << 12)
+#define MEM_CACHE_MAX_ENTRY_SIZE     (1 << 20)
+
+class nsHashtable;
+class nsMemCacheRecord;
+
+class nsMemCache : public nsINetDataCache
+{
+public:
+    nsMemCache();
+    virtual ~nsMemCache();
+    nsresult Init();
+
+    // nsISupports methods
+    NS_DECL_ISUPPORTS
+
+    // nsINetDataCache methods
+    NS_DECL_NSINETDATACACHE
+
+    // Factory
+    static NS_METHOD nsMemCacheConstructor(nsISupports *aOuter, REFNSIID aIID,
+                                           void **aResult);
+
+protected:
+
+    PRUint32         mNumEntries;
+    PRUint32         mOccupancy;   // Memory used, in bytes
+    PRBool           mEnabled;     // If false, bypass mem cache
+
+    nsINetDataCache* mNextCache;
+
+    // Mapping from either opaque key or record ID to nsMemCacheRecord
+    nsHashtable*     mHashTable;
+
+    // Used to assign record ID's
+    static PRInt32   gRecordSerialNumber;
+
+    NS_METHOD Delete(nsMemCacheRecord* aRecord);
+
+    friend class nsMemCacheRecord;
+    friend class nsMemCacheChannel;
+};
+
+#endif // _nsMemCache_h_

mozilla/netwerk/cache/memcache/nsMemCacheCID.h

@@ -0,0 +1,36 @@
+/* -*- 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.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 Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ */
+
+//  XPCOM Class ID for the network data in-memory cache
+
+#ifndef nsMEMCACHECID_h__
+#define nsMEMCACHECID_h__
+
+// {e4710560-7de2-11d3-90cb-0040056a906e}
+#define NS_MEM_CACHE_FACTORY_CID                          \
+    {                                                     \
+        0xe4710560,                                       \
+	    0x7de2,                                           \
+        0x11d3,                                           \
+	    {0x90, 0xcb, 0x00, 0x40, 0x05, 0x6a, 0x90, 0x6e}  \
+    }
+
+#endif // nsMEMCACHECID_h__

mozilla/netwerk/cache/memcache/nsMemCacheChannel.cpp

@@ -0,0 +1,462 @@
+/* -*- 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.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 Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ */
+
+#include "nsMemCache.h"
+#include "nsMemCacheChannel.h"
+#include "nsIStreamListener.h"
+#include "nsIChannel.h"
+#include "nsIStorageStream.h"
+#include "nsIOutputStream.h"
+#include "nsIServiceManager.h"
+#include "nsIEventQueueService.h"
+#include "nsNetUtil.h"
+#include "nsILoadGroup.h"
+
+static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
+static NS_DEFINE_CID(kEventQueueService, NS_EVENTQUEUESERVICE_CID);
+
+NS_IMPL_ISUPPORTS(nsMemCacheChannel, NS_GET_IID(nsIChannel))
+
+void
+nsMemCacheChannel::NotifyStorageInUse(PRInt32 aBytesUsed)
+{
+    mRecord->mCache->mOccupancy += aBytesUsed;
+}
+
+/**
+ * This class acts as an adaptor around a synchronous input stream to add async
+ * read capabilities.  It adds methods for initiating, suspending, resuming and
+ * cancelling async reads. 
+ */
+class AsyncReadStreamAdaptor : public nsIInputStream {
+public:
+    AsyncReadStreamAdaptor(nsMemCacheChannel* aChannel, nsIInputStream *aSyncStream):
+        mSyncStream(aSyncStream), mDataAvailCursor(0),
+        mRemaining(0), mAvailable(0), mChannel(aChannel), mAborted(PR_FALSE), mSuspended(PR_FALSE)
+        {
+            NS_INIT_REFCNT();
+            NS_ADDREF(mChannel);
+        }
+
+    virtual ~AsyncReadStreamAdaptor() { 
+        mChannel->mAsyncReadStream = 0;
+        NS_RELEASE(mChannel);
+    }
+    
+    NS_DECL_ISUPPORTS
+
+    nsresult
+    IsPending(PRBool* aIsPending) {
+        *aIsPending = (mRemaining != 0) && !mAborted;
+        return NS_OK;
+    }
+
+    nsresult
+    Cancel(void) {
+        mAborted = PR_TRUE;
+        return mStreamListener->OnStopRequest(mChannel, mContext, NS_BINDING_ABORTED, nsnull);
+    }
+
+    nsresult
+    Suspend(void) { mSuspended = PR_TRUE; return NS_OK; }
+
+    nsresult
+    Resume(void) {
+        if (!mSuspended)
+            return NS_ERROR_FAILURE;
+        mSuspended = PR_FALSE;
+        return NextListenerEvent();
+    }
+
+    NS_IMETHOD
+    Available(PRUint32 *aNumBytes) { return mAvailable; }
+
+    NS_IMETHOD
+    Read(char* aBuf, PRUint32 aCount, PRUint32 *aBytesRead) {
+        if (mAborted)
+            return NS_ERROR_ABORT;
+
+        *aBytesRead = 0;
+        aCount = PR_MIN(aCount, mAvailable);
+        nsresult rv = mSyncStream->Read(aBuf, aCount, aBytesRead);
+        mAvailable -= *aBytesRead;
+
+        if (NS_FAILED(rv) && (rv != NS_BASE_STREAM_WOULD_BLOCK)) {
+            Fail();
+            return rv;
+        }
+
+        if (!mSuspended && !mAvailable) {
+            rv = NextListenerEvent();
+            if (NS_FAILED(rv)) {
+                Fail();
+                return rv;
+            }
+        }
+
+        return NS_OK;
+    }
+
+    NS_IMETHOD
+    Close() {
+        nsresult rv = mSyncStream->Close();
+        mSyncStream = 0;
+        mContext = 0;
+        mStreamListener = 0;
+        return rv;
+    }
+
+    nsresult
+    AsyncRead(PRUint32 aStartPosition, PRInt32 aReadCount,
+              nsISupports* aContext, nsIStreamListener* aListener) {
+
+        nsresult rv;
+        nsIEventQueue *eventQ;
+
+        mContext = aContext;
+        mStreamListener = aListener;
+        mRemaining = aReadCount;
+
+        NS_WITH_SERVICE(nsIIOService, serv, kIOServiceCID, &rv);
+        if (NS_FAILED(rv)) return rv;
+
+        NS_WITH_SERVICE(nsIEventQueueService, eventQService, kEventQueueService, &rv);
+        if (NS_FAILED(rv)) return rv;
+
+        rv = eventQService->GetThreadEventQueue(PR_CurrentThread(), &eventQ);
+        if (NS_FAILED(rv)) return rv;
+
+        rv = NS_NewAsyncStreamListener(aListener, eventQ, 
+                                       getter_AddRefs(mStreamListener));
+        NS_RELEASE(eventQ);
+        if (NS_FAILED(rv)) return rv;
+
+        rv = mStreamListener->OnStartRequest(mChannel, aContext);
+        if (NS_FAILED(rv)) return rv;
+
+        return NextListenerEvent();
+    }
+
+protected:
+
+    nsresult
+    Fail(void) {
+        mAborted = PR_TRUE;
+        return mStreamListener->OnStopRequest(mChannel, mContext, NS_BINDING_FAILED, nsnull);
+    }
+
+    nsresult
+    NextListenerEvent() {
+        PRUint32 available;
+        nsresult rv = mSyncStream->Available(&available);
+        if (NS_FAILED(rv)) return rv;
+        available -= mAvailable;
+        available = PR_MIN(available, mRemaining);
+
+        if (available) {
+            PRUint32 size = PR_MIN(available, MEM_CACHE_SEGMENT_SIZE);
+            rv = mStreamListener->OnDataAvailable(mChannel, mContext, this,
+                                                  mDataAvailCursor, size);
+            mDataAvailCursor += size;
+            mRemaining -= size;
+            mAvailable += size;
+            return rv;
+        } else {
+            rv = mStreamListener->OnStopRequest(mChannel, mContext, NS_OK, nsnull);
+            AsyncReadStreamAdaptor* thisAlias = this;
+            NS_RELEASE(thisAlias);
+            return rv;
+        }
+    }
+    
+private:
+    nsCOMPtr<nsISupports>       mContext;        // Opaque context passed to AsyncRead()
+    nsCOMPtr<nsIStreamListener> mStreamListener; // Stream listener that has been proxied
+    nsCOMPtr<nsIInputStream>    mSyncStream;     // Underlying synchronous stream that is
+                                                 //   being converted to an async stream
+    PRUint32                    mDataAvailCursor;
+    PRUint32                    mRemaining;      // Size of AsyncRead request less bytes for
+                                                 //   consumer OnDataAvailable's that were fired
+    PRUint32                    mAvailable;      // Number of bytes for which OnDataAvailable fired
+    nsMemCacheChannel*          mChannel;        // Associated memory cache channel, strong link
+                                                 //   but can not use nsCOMPtr
+    PRBool                      mAborted;        // Abort() has been called
+    PRBool                      mSuspended;      // Suspend() has been called
+};
+
+NS_IMPL_ISUPPORTS(AsyncReadStreamAdaptor,  NS_GET_IID(nsIInputStream))
+
+// The only purpose of this output stream wrapper is to adjust the cache's
+// overall occupancy as new data flows into the cache entry.
+class MemCacheWriteStreamWrapper : public nsIOutputStream {
+public:
+    MemCacheWriteStreamWrapper(nsMemCacheChannel* aChannel, nsIOutputStream *aBaseStream):
+        mBaseStream(aBaseStream), mChannel(aChannel)
+        {
+            NS_INIT_REFCNT();
+            NS_ADDREF(mChannel);
+        }
+
+    virtual ~MemCacheWriteStreamWrapper() { NS_RELEASE(mChannel); };
+    
+    static nsresult
+    Create(nsMemCacheChannel* aChannel, nsIOutputStream *aBaseStream, nsIOutputStream* *aWrapper) {
+        MemCacheWriteStreamWrapper *wrapper =
+            new MemCacheWriteStreamWrapper(aChannel, aBaseStream);
+        if (!wrapper) return NS_ERROR_OUT_OF_MEMORY;
+        NS_ADDREF(wrapper);
+        *aWrapper = wrapper;
+        return NS_OK;
+    }
+    
+    NS_DECL_ISUPPORTS
+
+    NS_IMETHOD
+    Write(const char *aBuffer, PRUint32 aCount, PRUint32 *aNumWritten) {
+        *aNumWritten = 0;
+        nsresult rv = mBaseStream->Write(aBuffer, aCount, aNumWritten);
+        mChannel->NotifyStorageInUse(*aNumWritten);
+        return rv;
+    }
+
+    NS_IMETHOD
+    Flush() { return mBaseStream->Flush(); }
+
+    NS_IMETHOD
+    Close() { return mBaseStream->Close(); }
+
+private:
+    nsCOMPtr<nsIOutputStream>   mBaseStream;
+    nsMemCacheChannel*          mChannel;
+};
+
+NS_IMPL_ISUPPORTS(MemCacheWriteStreamWrapper,  NS_GET_IID(nsIOutputStream))
+
+nsMemCacheChannel::nsMemCacheChannel(nsMemCacheRecord *aRecord, nsILoadGroup *aLoadGroup)
+    : mRecord(aRecord)
+{
+    NS_INIT_REFCNT();
+    mRecord->mNumChannels++;
+}
+
+nsMemCacheChannel::~nsMemCacheChannel()
+{
+    mRecord->mNumChannels--;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::IsPending(PRBool* aIsPending)
+{
+    *aIsPending = PR_FALSE;
+    if (!mAsyncReadStream)
+        return NS_OK;
+    return mAsyncReadStream->IsPending(aIsPending);
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::Cancel(void)
+{
+    if (!mAsyncReadStream)
+        return NS_ERROR_FAILURE;
+    return mAsyncReadStream->Cancel();
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::Suspend(void)
+{
+    if (!mAsyncReadStream)
+        return NS_ERROR_FAILURE;
+    return mAsyncReadStream->Suspend();
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::Resume(void)
+{
+    if (!mAsyncReadStream)
+        return NS_ERROR_FAILURE;
+    return mAsyncReadStream->Resume();
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::GetOriginalURI(nsIURI * *aURI)
+{
+    // Not required
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::GetURI(nsIURI * *aURI)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::OpenInputStream(PRUint32 aStartPosition, PRInt32 aReadCount,
+                                   nsIInputStream* *aResult)
+{
+    nsresult rv;
+    NS_ENSURE_ARG(aResult);
+    if (mInputStream)
+        return NS_ERROR_NOT_AVAILABLE;
+
+    rv = mRecord->mStorageStream->NewInputStream(aStartPosition, getter_AddRefs(mInputStream));
+    *aResult = mInputStream;
+    NS_ADDREF(*aResult);
+    return rv;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::OpenOutputStream(PRUint32 startPosition, nsIOutputStream* *aResult)
+{
+    nsresult rv;
+    NS_ENSURE_ARG(aResult);
+
+    nsCOMPtr<nsIOutputStream> outputStream;
+
+    PRUint32 oldLength;
+    mRecord->mStorageStream->GetLength(&oldLength);
+    rv = mRecord->mStorageStream->GetOutputStream(startPosition, getter_AddRefs(outputStream));
+    if (NS_FAILED(rv)) return rv;
+    if (startPosition < oldLength)
+        NotifyStorageInUse(startPosition - oldLength);
+
+    return MemCacheWriteStreamWrapper::Create(this, outputStream, aResult);
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::AsyncOpen(nsIStreamObserver *observer, nsISupports *ctxt)
+{
+    // Not required
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::AsyncRead(PRUint32 aStartPosition, PRInt32 aReadCount,
+                             nsISupports *aContext, nsIStreamListener *aListener)
+{
+    nsCOMPtr<nsIInputStream> inputStream;
+    nsresult rv = OpenInputStream(aStartPosition, aReadCount, getter_AddRefs(inputStream));
+    if (NS_FAILED(rv)) return rv;
+    
+    AsyncReadStreamAdaptor *asyncReadStreamAdaptor;
+    asyncReadStreamAdaptor = new AsyncReadStreamAdaptor(this, inputStream);
+    if (!asyncReadStreamAdaptor)
+        return NS_ERROR_OUT_OF_MEMORY;
+    NS_ADDREF(asyncReadStreamAdaptor);
+    mAsyncReadStream = asyncReadStreamAdaptor;
+
+    rv = asyncReadStreamAdaptor->AsyncRead(aStartPosition, aReadCount, aContext, aListener);
+    if (NS_FAILED(rv))
+        delete asyncReadStreamAdaptor;
+    return rv;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::AsyncWrite(nsIInputStream *fromStream, PRUint32 startPosition,
+                              PRInt32 writeCount, nsISupports *ctxt,
+                              nsIStreamObserver *observer)
+{
+    // Not required to be implemented
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::GetLoadAttributes(nsLoadFlags *aLoadAttributes)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::SetLoadAttributes(nsLoadFlags aLoadAttributes)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::GetContentType(char* *aContentType)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::GetContentLength(PRInt32 *aContentLength)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::GetOwner(nsISupports* *aOwner)
+{
+    *aOwner = mOwner.get();
+    NS_IF_ADDREF(*aOwner);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::SetOwner(nsISupports* aOwner)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    mOwner = aOwner;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::GetLoadGroup(nsILoadGroup* *aLoadGroup)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::SetLoadGroup(nsILoadGroup* aLoadGroup)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::GetNotificationCallbacks(nsIInterfaceRequestor* *aNotificationCallbacks)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::SetNotificationCallbacks(nsIInterfaceRequestor* aNotificationCallbacks)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}

mozilla/netwerk/cache/memcache/nsMemCacheChannel.h

@@ -0,0 +1,61 @@
+/* -*- 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.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 Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ */
+
+#ifndef _nsMemCacheChannel_h_
+#define _nsMemCacheChannel_h_
+
+#include "nsMemCacheRecord.h"
+#include "nsIChannel.h"
+#include "nsIInputStream.h"
+#include "nsCOMPtr.h"
+
+
+class AsyncReadStreamAdaptor;
+
+class nsMemCacheChannel : public nsIChannel
+{
+public:
+    // Constructors and Destructor
+    nsMemCacheChannel(nsMemCacheRecord *aRecord, nsILoadGroup *aLoadGroup);
+    virtual ~nsMemCacheChannel();
+
+    // Declare nsISupports methods
+    NS_DECL_ISUPPORTS
+
+    // Declare nsIRequest methods
+    NS_DECL_NSIREQUEST
+
+    // Declare nsIChannel methods
+    NS_DECL_NSICHANNEL
+
+protected:
+    void NotifyStorageInUse(PRInt32 aBytesUsed);
+
+    nsCOMPtr<nsMemCacheRecord>   mRecord;
+    nsCOMPtr<nsIInputStream>     mInputStream;
+    nsCOMPtr<nsISupports>        mOwner;
+    AsyncReadStreamAdaptor*      mAsyncReadStream; // non-owning pointer
+
+    friend class MemCacheWriteStreamWrapper;
+    friend class AsyncReadStreamAdaptor;
+};
+
+#endif // _nsMemCacheChannel_h_

mozilla/netwerk/cache/memcache/nsMemCacheRecord.cpp

@@ -0,0 +1,164 @@
+/* -*- 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.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 Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ */
+
+#include "nsMemCache.h"
+#include "nsMemCacheRecord.h"
+#include "nsMemCacheChannel.h"
+#include "nsIAllocator.h"
+#include "nsStorageStream.h"
+
+static NS_DEFINE_IID(kINetDataCacheRecord, NS_INETDATACACHERECORD_IID);
+
+nsMemCacheRecord::nsMemCacheRecord()
+    : mKey(0), mKeyLength(0), mMetaData(0), mMetaDataLength(0), mNumChannels(0)
+{
+    NS_INIT_REFCNT();
+}
+
+nsMemCacheRecord::~nsMemCacheRecord()
+{
+    if (mMetaData)
+        delete[] mMetaData;
+    if (mKey)
+        delete[] mKey;
+}	
+     
+NS_IMPL_ISUPPORTS(nsMemCacheRecord, NS_GET_IID(nsINetDataCacheRecord))
+
+NS_IMETHODIMP
+nsMemCacheRecord::GetKey(PRUint32 *aLength, char **aResult)
+{
+    NS_ENSURE_ARG(aResult);
+    *aResult = (char *)nsAllocator::Alloc(mKeyLength);
+    if (!*aResult)
+        return NS_ERROR_OUT_OF_MEMORY;
+    memcpy(*aResult, mKey, mKeyLength);
+    *aLength = mKeyLength;
+    return NS_OK;
+}
+
+nsresult
+nsMemCacheRecord::Init(const char *aKey, PRUint32 aKeyLength,
+                       PRUint32 aRecordID, nsMemCache *aCache)
+{
+    nsresult rv;
+
+    NS_ASSERTION(!mKey, "Memory cache record key set multiple times");
+
+    rv = NS_NewStorageStream(MEM_CACHE_SEGMENT_SIZE, MEM_CACHE_MAX_ENTRY_SIZE,
+                             getter_AddRefs(mStorageStream));
+    if (NS_FAILED(rv)) return rv;
+
+    mKey = new char[aKeyLength];
+    if (!mKey)
+        return NS_ERROR_OUT_OF_MEMORY;
+    memcpy(mKey, aKey, aKeyLength);
+    mKeyLength = aKeyLength;
+    mRecordID = aRecordID;
+    mCache = aCache;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCacheRecord::GetRecordID(PRInt32 *aRecordID)
+{
+    NS_ENSURE_ARG(aRecordID);
+    *aRecordID = mRecordID;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCacheRecord::GetMetaData(PRUint32 *aLength, char **aResult)
+{
+    NS_ENSURE_ARG(aResult);
+
+    *aResult = 0;
+    if (mMetaDataLength) {
+        *aResult = (char*)nsAllocator::Alloc(mMetaDataLength);
+        if (!*aResult)
+            return NS_ERROR_OUT_OF_MEMORY;
+        memcpy(*aResult, mMetaData, mMetaDataLength);
+    }
+    *aLength = mMetaDataLength;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCacheRecord::SetMetaData(PRUint32 aLength, const char *aData)
+{
+    if (mMetaData)
+        delete[] mMetaData;
+    mMetaData = new char[aLength];
+    if (!mMetaData)
+        return NS_ERROR_OUT_OF_MEMORY;
+    memcpy(mMetaData, aData, aLength);
+    mMetaDataLength = aLength;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCacheRecord::GetStoredContentLength(PRUint32 *aStoredContentLength)
+{
+    NS_ENSURE_ARG(aStoredContentLength);
+    return mStorageStream->GetLength(aStoredContentLength);
+}
+
+NS_IMETHODIMP
+nsMemCacheRecord::SetStoredContentLength(PRUint32 aStoredContentLength)
+{
+    PRUint32 before, after;
+    mStorageStream->GetLength(&before);
+    nsresult rv = mStorageStream->SetLength(aStoredContentLength);
+    if (NS_FAILED(rv)) return rv;
+    mStorageStream->GetLength(&after);
+    mCache->mOccupancy -= (before - after);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCacheRecord::Delete(void)
+{
+    if (mNumChannels)
+        return NS_ERROR_NOT_AVAILABLE;
+  
+    return mCache->Delete(this);
+}
+
+NS_IMETHODIMP
+nsMemCacheRecord::GetFilename(nsIFileSpec* *aFilename)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheRecord::NewChannel(nsILoadGroup *aLoadGroup, nsIChannel* *aResult)
+{
+    NS_ENSURE_ARG(aResult);
+
+    nsMemCacheChannel* channel = new nsMemCacheChannel(this, aLoadGroup);
+    if (!channel)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    NS_ADDREF(channel);
+    *aResult = NS_STATIC_CAST(nsIChannel*, channel);
+    return NS_OK;
+
+}

mozilla/netwerk/cache/memcache/nsMemCacheRecord.h

@@ -0,0 +1,65 @@
+/* -*- 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.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 Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ */
+
+#ifndef _nsMemCacheRecord_h_
+#define _nsMemCacheRecord_h_
+
+#include "nsINetDataCacheRecord.h"
+#include "nsIStorageStream.h"
+#include "nsCOMPtr.h"
+
+class nsMemCache;
+
+class nsMemCacheRecord : public nsINetDataCacheRecord
+{
+
+public:
+    // Declare interface methods
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSINETDATACACHERECORD
+
+protected:
+    // Constructors and Destructor
+    nsMemCacheRecord();
+    virtual ~nsMemCacheRecord();
+
+    nsresult Init(const char *aKey, PRUint32 aKeyLength,
+                  PRUint32 aRecordID, nsMemCache *aCache);
+
+    char*       mKey;              // opaque database key for this record
+    PRUint32    mKeyLength;        // length, in bytes, of mKey
+
+    PRInt32     mRecordID;         // An alternate key for this record
+
+    char*       mMetaData;         // opaque URI metadata
+    PRUint32    mMetaDataLength;   // length, in bytes, of mMetaData
+
+    nsMemCache* mCache;            // weak pointer to the cache database
+                                   //  that this record inhabits
+
+    nsCOMPtr<nsIStorageStream> mStorageStream;
+    PRUint32    mNumChannels;      // Count un-Release'ed nsIChannels
+
+    friend class nsMemCache;
+    friend class nsMemCacheChannel;
+};
+
+#endif // _nsMemCacheRecord_h_

mozilla/netwerk/cache/mgr/Makefile.in

@@ -0,0 +1,55 @@
+#
+# 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
+
+MODULE		= nkcache 
+LIBRARY_NAME	= nkcachemgr_s
+
+REQUIRES	= nspr
+
+EXPORTS		= \
+		nsCacheManager.h \
+		$(NULL)
+
+CPPSRCS		= \
+        nsCacheManager.cpp \
+        nsCachedNetData.cpp \
+        nsReplacementPolicy.cpp \
+        nsCacheEntryChannel.cpp \
+		$(NULL)
+
+LOCAL_INCLUDES	= -I$(srcdir)/../public -I$(srcdir)/../include
+
+EXTRA_LIBS	= $(NSPR_LIBS)
+
+# we don't want the shared lib, but we want to force the creation of a
+# static lib.
+override NO_SHARED_LIB=1
+override NO_STATIC_LIB=
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/netwerk/cache/mgr/Makefile.win

@@ -1,4 +1,4 @@
-#!nmake
+#!gmake
 #
 # The contents of this file are subject to the Netscape Public
 # License Version 1.1 (the "License"); you may not use this file
@@ -19,27 +19,27 @@
 #
 # Contributor(s): 
 
-DEPTH=..\..\..\..
+DEPTH=..\..\..
 
-include <$(DEPTH)\config\config.mak>
+include <$(DEPTH)/config/config.mak>
 
-LIBRARY_NAME=nlslayer
+MODULE = nkcache
 
-CPPSRCS =				\
-	nlslayer.cpp		\
+LIBRARY_NAME = nkcachemgr_s
+
+CPP_OBJS =                                   \
+	.\$(OBJDIR)\nsCacheManager.obj       \
+	.\$(OBJDIR)\nsCachedNetData.obj      \
+	.\$(OBJDIR)\nsReplacementPolicy.obj  \
+	.\$(OBJDIR)\nsCacheEntryChannel.obj  \
 	$(NULL)
 
-CPP_OBJS =					\
-	.\$(OBJDIR)\nlslayer.obj		\
-	$(NULL)
-
-MODULE=security
-
-LIBRARY_NAME = nlslayer
-LIBRARY=.\$(OBJDIR)\$(DLLNAME).dll
-
-include <$(DEPTH)\config\rules.mak>
+include <$(DEPTH)\config\rules.mak> 
 
 install:: $(LIBRARY)
-        $(MAKE_INSTALL) $(LIBRARY) $(DIST)\lib
+	$(MAKE_INSTALL) $(LIBRARY) $(DIST)\lib
+
 clobber::
+        rm -rf $(OBJDIR)
+        rm -f $(DIST)\lib\$(LIBRARY_NAME).lib
+

mozilla/netwerk/cache/mgr/nsCacheEntryChannel.cpp

@@ -0,0 +1,261 @@
+/* -*- 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.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 Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *   Scott Furman, fur@netscape.com
+ */
+
+#include "nsCacheManager.h"
+#include "nsCacheEntryChannel.h"
+#include "nsIOutputStream.h"
+#include "nsIIOService.h"
+#include "nsIServiceManager.h"
+#include "nsIStreamListener.h"
+
+nsCacheEntryChannel::nsCacheEntryChannel(nsCachedNetData* aCacheEntry, nsIChannel* aChannel,
+                                         nsILoadGroup* aLoadGroup):
+    nsChannelProxy(aChannel), mCacheEntry(aCacheEntry), mLoadGroup(aLoadGroup), mLoadAttributes(0)
+{
+    NS_ASSERTION(aCacheEntry->mChannelCount < 0xFF, "Overflowed channel counter");
+    mCacheEntry->mChannelCount++;
+    NS_INIT_REFCNT();
+}
+
+nsCacheEntryChannel::~nsCacheEntryChannel()
+{
+    mCacheEntry->mChannelCount--;
+}
+
+NS_IMPL_ISUPPORTS3(nsCacheEntryChannel, nsISupports, nsIChannel, nsIRequest)
+
+// A proxy for nsIOutputStream
+class CacheOutputStream : public nsIOutputStream {
+
+public:
+    CacheOutputStream(nsIOutputStream *aOutputStream, nsCachedNetData *aCacheEntry):
+        mOutputStream(aOutputStream), mCacheEntry(aCacheEntry), mStartTime(PR_Now())
+        { NS_INIT_REFCNT(); }
+
+    virtual ~CacheOutputStream() {
+        mCacheEntry->NoteDownloadTime(mStartTime, PR_Now());
+        mCacheEntry->ClearFlag(nsCachedNetData::UPDATE_IN_PROGRESS);
+    }
+    
+    NS_DECL_ISUPPORTS
+
+    NS_IMETHOD Close() {
+        return mOutputStream->Close();
+    }
+
+    NS_IMETHOD Flush() { return mOutputStream->Flush(); }
+
+    NS_IMETHOD
+    Write(const char *aBuf, PRUint32 aCount, PRUint32 *aActualBytes) {
+        nsresult rv;
+    
+        *aActualBytes = 0;
+        rv = mOutputStream->Write(aBuf, aCount, aActualBytes);
+        mCacheEntry->mLogicalLength += *aActualBytes;
+        if (NS_FAILED(rv)) return rv;
+        nsCacheManager::LimitCacheSize();
+        return rv;
+    }
+    
+protected:
+    nsCOMPtr<nsIOutputStream> mOutputStream;
+    nsCOMPtr<nsCachedNetData> mCacheEntry;
+
+    // Time at which stream was opened
+    PRTime mStartTime;
+};
+
+NS_IMPL_ISUPPORTS(CacheOutputStream, NS_GET_IID(nsIOutputStream))
+
+NS_IMETHODIMP
+nsCacheEntryChannel::OpenOutputStream(PRUint32 aStartPosition, nsIOutputStream* *aOutputStream)
+{
+    nsresult rv;
+    nsCOMPtr<nsIOutputStream> baseOutputStream;
+    
+    rv = mChannel->OpenOutputStream(aStartPosition, getter_AddRefs(baseOutputStream));
+    if (NS_FAILED(rv)) return rv;
+
+    mCacheEntry->NoteUpdate();
+    mCacheEntry->NoteAccess();
+    mCacheEntry->mLogicalLength = aStartPosition;
+
+    *aOutputStream = new CacheOutputStream(baseOutputStream, mCacheEntry);
+    if (!*aOutputStream)
+        return NS_ERROR_OUT_OF_MEMORY;
+    NS_ADDREF(*aOutputStream);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheEntryChannel::OpenInputStream(PRUint32 aStartPosition, PRInt32 aReadCount,
+				     nsIInputStream* *aInputStream)
+{
+    mCacheEntry->NoteAccess();
+    return mChannel->OpenInputStream(aStartPosition, aReadCount, aInputStream);
+}
+
+class CacheManagerStreamListener: public nsIStreamListener  {
+
+    public:
+    
+    CacheManagerStreamListener(nsIStreamListener *aListener,
+                               nsILoadGroup *aLoadGroup, nsIChannel *aChannel):
+        mListener(aListener), mLoadGroup(aLoadGroup), mChannel(aChannel)
+        { NS_INIT_REFCNT(); }
+
+    virtual ~CacheManagerStreamListener() {}
+
+    private:
+
+    NS_DECL_ISUPPORTS
+
+    NS_IMETHOD
+    OnDataAvailable(nsIChannel *channel, nsISupports *aContext,
+                    nsIInputStream *inStr, PRUint32 sourceOffset, PRUint32 count) {
+        return mListener->OnDataAvailable(mChannel, aContext, inStr, sourceOffset, count);
+    }
+
+    NS_IMETHOD
+    OnStartRequest(nsIChannel *channel, nsISupports *aContext) {
+        if (mLoadGroup)
+            mLoadGroup->AddChannel(mChannel, aContext);
+        return mListener->OnStartRequest(mChannel, aContext);
+    }
+
+    NS_IMETHOD
+    OnStopRequest(nsIChannel *channel, nsISupports *aContext,
+                  nsresult status, const PRUnichar *errorMsg) {
+        nsresult rv;
+        rv = mListener->OnStopRequest(mChannel, aContext, status, errorMsg);
+        if (mLoadGroup)
+            mLoadGroup->RemoveChannel(mChannel, aContext, status, errorMsg);
+        return rv;
+    }
+
+    private:
+    
+    nsCOMPtr<nsIStreamListener>  mListener;
+    nsCOMPtr<nsILoadGroup>       mLoadGroup;
+    nsCOMPtr<nsIChannel>         mChannel;
+};
+
+NS_IMPL_ISUPPORTS2(CacheManagerStreamListener, nsIStreamListener, nsIStreamObserver)
+
+NS_IMETHODIMP
+nsCacheEntryChannel::AsyncRead(PRUint32 aStartPosition, PRInt32 aReadCount,
+                               nsISupports *aContext, nsIStreamListener *aListener)
+{
+    nsresult rv;
+
+    mCacheEntry->NoteAccess();
+
+    nsCOMPtr<nsIStreamListener> headListener;
+    if (mLoadGroup) {
+        mLoadGroup->GetDefaultLoadAttributes(&mLoadAttributes);
+
+        // Create a load group "proxy" listener...
+        nsCOMPtr<nsILoadGroupListenerFactory> factory;
+        rv = mLoadGroup->GetGroupListenerFactory(getter_AddRefs(factory));
+        if (NS_SUCCEEDED(rv) && factory) {
+            rv = factory->CreateLoadGroupListener(aListener, 
+                                                  getter_AddRefs(headListener));
+            if (NS_FAILED(rv)) return rv;
+        }
+
+    } else {
+        headListener = aListener;
+    }
+
+    CacheManagerStreamListener* cacheManagerStreamListener;
+    nsIChannel *channelForListener;
+
+    channelForListener = mProxyChannel ? mProxyChannel.get() : NS_STATIC_CAST(nsIChannel*, this);
+    cacheManagerStreamListener =
+        new CacheManagerStreamListener(headListener, mLoadGroup, channelForListener);
+    if (!cacheManagerStreamListener) return NS_ERROR_OUT_OF_MEMORY;
+    
+    NS_ADDREF(cacheManagerStreamListener);
+    rv = mChannel->AsyncRead(aStartPosition, aReadCount, aContext,
+                             cacheManagerStreamListener);
+    NS_RELEASE(cacheManagerStreamListener);
+
+    return rv;
+}
+
+// No async writes allowed to the cache yet
+NS_IMETHODIMP
+nsCacheEntryChannel::AsyncWrite(nsIInputStream *aFromStream, PRUint32 aStartPosition,
+				PRInt32 aWriteCount, nsISupports *aContext,
+				nsIStreamObserver *aObserver)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsCacheEntryChannel::GetLoadGroup(nsILoadGroup* *aLoadGroup)
+{
+    *aLoadGroup = mLoadGroup;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheEntryChannel::GetLoadAttributes(nsLoadFlags *aLoadAttributes)
+{
+    *aLoadAttributes = mLoadAttributes;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheEntryChannel::SetLoadAttributes(nsLoadFlags aLoadAttributes)
+{
+    mLoadAttributes = aLoadAttributes;
+    return NS_OK;
+}
+
+static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
+
+NS_IMETHODIMP
+nsCacheEntryChannel::GetURI(nsIURI * *aURI)
+{
+    char* spec;
+    nsresult rv;
+
+    rv = mCacheEntry->GetUriSpec(&spec);
+    if (NS_FAILED(rv)) return rv;
+
+    NS_WITH_SERVICE(nsIIOService, serv, kIOServiceCID, &rv);
+    if (NS_FAILED(rv)) return rv;
+    
+    rv = serv->NewURI(spec, 0, aURI);
+    nsAllocator::Free(spec);
+    return rv;
+}
+
+NS_IMETHODIMP
+nsCacheEntryChannel::GetOriginalURI(nsIURI * *aURI)
+{
+    // FIXME - should return original URI passed into NewChannel() ?
+    return NS_ERROR_NOT_IMPLEMENTED;
+}

mozilla/netwerk/cache/mgr/nsCacheEntryChannel.h

@@ -0,0 +1,82 @@
+/* -*- 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.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 Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *   Scott Furman, fur@netscape.com
+ */
+
+#ifndef _nsCacheEntryChannel_h_
+#define _nsCacheEntryChannel_h_
+
+#include "nsCOMPtr.h"
+#include "nsIChannel.h"
+#include "nsCachedNetData.h"
+#include "nsILoadGroup.h"
+
+class nsIStreamListener;
+
+// A proxy for an nsIChannel, useful when only a few nsIChannel
+// methods must be overridden
+class nsChannelProxy : public nsIChannel {
+
+public:
+    NS_FORWARD_NSICHANNEL(mChannel->)
+    NS_FORWARD_NSIREQUEST(mChannel->)
+
+protected:
+    nsChannelProxy(nsIChannel* aChannel):mChannel(aChannel) {};
+    virtual ~nsChannelProxy() {};
+    nsCOMPtr<nsIChannel>      mChannel;
+};
+
+// Override several nsIChannel methods so that they interact with the cache manager
+class nsCacheEntryChannel : public nsChannelProxy {
+
+public:
+    NS_DECL_ISUPPORTS
+
+    NS_IMETHOD OpenOutputStream(PRUint32 aStartPosition, nsIOutputStream* *aOutputStream);
+    NS_IMETHOD OpenInputStream(PRUint32 aStartPosition, PRInt32 aReadCount,
+			       nsIInputStream* *aInputStream);
+    NS_IMETHOD AsyncRead(PRUint32 aStartPosition, PRInt32 aReadCount,
+			 nsISupports *aContext, nsIStreamListener *aListener);
+    NS_IMETHOD AsyncWrite(nsIInputStream *aFromStream, PRUint32 aStartPosition,
+			  PRInt32 aWriteCount, nsISupports *aContext,
+			  nsIStreamObserver *aObserver);
+    NS_IMETHOD GetLoadAttributes(nsLoadFlags *aLoadAttributes);
+    NS_IMETHOD SetLoadAttributes(nsLoadFlags aLoadAttributes);
+    NS_IMETHOD GetLoadGroup(nsILoadGroup* *aLoadGroup);
+    NS_IMETHOD GetURI(nsIURI * *aURI);
+    NS_IMETHOD GetOriginalURI(nsIURI * *aURI);
+
+protected:
+    nsCacheEntryChannel(nsCachedNetData* aCacheEntry, nsIChannel* aChannel, nsILoadGroup* aLoadGroup);
+    virtual ~nsCacheEntryChannel();
+
+    friend class nsCachedNetData;
+
+private:
+    nsCOMPtr<nsCachedNetData>    mCacheEntry;
+    nsCOMPtr<nsILoadGroup>       mLoadGroup;
+    nsCOMPtr<nsIChannel>         mProxyChannel;
+    nsLoadFlags                  mLoadAttributes;
+};
+
+#endif // _nsCacheEntryChannel_h_

mozilla/netwerk/cache/mgr/nsCacheManager.cpp

@@ -0,0 +1,497 @@
+/* -*- 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.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 Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *   Scott Furman, fur@netscape.com
+ */
+
+#include "nsINetDataCache.h"
+#include "nsCacheManager.h"
+#include "nsCachedNetData.h"
+#include "nsReplacementPolicy.h"
+#include "nsString.h"
+#include "nsIURI.h"
+#include "nsHashtable.h"
+#include "nsIComponentManager.h"
+#include "nsINetDataDiskCache.h"
+
+// Limit the number of entries in the cache to conserve memory space
+// in the nsReplacementPolicy code
+#define MAX_MEM_CACHE_ENTRIES    800
+#define MAX_DISK_CACHE_ENTRIES  3200
+
+// Cache capacities in MB, overridable via APIs
+#define DEFAULT_MEMORY_CACHE_CAPACITY  1024
+#define DEFAULT_DISK_CACHE_CAPACITY   10000
+
+#define CACHE_HIGH_WATER_MARK(capacity) ((PRUint32)(0.98 * (capacity)))
+#define CACHE_LOW_WATER_MARK(capacity)  ((PRUint32)(0.97 * (capacity)))
+
+nsCacheManager* gCacheManager = 0;
+
+NS_IMPL_ISUPPORTS(nsCacheManager, NS_GET_IID(nsINetDataCacheManager))
+
+nsCacheManager::nsCacheManager()
+    : mActiveCacheRecords(0),
+    mDiskCacheCapacity(DEFAULT_DISK_CACHE_CAPACITY),
+    mMemCacheCapacity(DEFAULT_MEMORY_CACHE_CAPACITY)
+{
+    NS_ASSERTION(!gCacheManager, "Multiple cache managers created");
+    gCacheManager = this;
+    NS_INIT_REFCNT();
+}
+
+nsCacheManager::~nsCacheManager()
+{
+    gCacheManager = 0;
+    delete mActiveCacheRecords;
+    delete mMemSpaceManager;
+    delete mDiskSpaceManager;
+}
+
+nsresult
+nsCacheManager::Init()
+{
+    nsresult rv;
+
+    mActiveCacheRecords = new nsHashtable(64);
+    if (!mActiveCacheRecords)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    // Instantiate the memory cache component
+    rv = nsComponentManager::CreateInstance(NS_NETWORK_MEMORY_CACHE_PROGID,
+                                            nsnull,
+                                            NS_GET_IID(nsINetDataCache),
+                                            getter_AddRefs(mMemCache));
+    if (NS_FAILED(rv))
+        return rv;
+
+    rv = nsComponentManager::CreateInstance(NS_NETWORK_FLAT_CACHE_PROGID,
+                                            nsnull,
+                                            NS_GET_IID(nsINetDataCache),
+
+                                            getter_AddRefs(mFlatCache));
+
+    if (NS_FAILED(rv)) {
+        // For now, we don't require a flat cache module to be present
+        if (rv != NS_ERROR_FACTORY_NOT_REGISTERED)
+            return rv;
+    }
+
+#ifdef FILE_CACHE_IS_READY
+    // Instantiate the file cache component
+    rv = nsComponentManager::CreateInstance(NS_NETWORK_FILE_CACHE_PROGID,
+                                            nsnull,
+                                            NS_GET_IID(nsINetDataCache),
+                                            getter_AddRefs(mFileCache));
+    if (NS_FAILED(rv)) {
+        NS_WARNING("No disk cache present");
+    }
+#endif
+
+    // Set up linked list of caches in search order
+    mCacheSearchChain = mMemCache;
+    if (mFlatCache) {
+        mMemCache->SetNextCache(mFlatCache);
+        mFlatCache->SetNextCache(mFileCache);
+    } else {
+        mMemCache->SetNextCache(mFileCache);
+    }
+
+    // TODO - Load any extension caches here
+
+    // Initialize replacement policy for memory cache module
+    mMemSpaceManager = new nsReplacementPolicy;
+    if (!mMemSpaceManager)
+        return NS_ERROR_OUT_OF_MEMORY;
+    rv = mMemSpaceManager->Init(MAX_MEM_CACHE_ENTRIES);
+    if (NS_FAILED(rv)) return rv;
+    rv = mMemSpaceManager->AddCache(mMemCache);
+
+    // Initialize replacement policy for disk cache modules (file
+    // cache and flat cache)
+    mDiskSpaceManager = new nsReplacementPolicy;
+    if (!mDiskSpaceManager)
+        return NS_ERROR_OUT_OF_MEMORY;
+    rv = mDiskSpaceManager->Init(MAX_DISK_CACHE_ENTRIES);
+    if (NS_FAILED(rv)) return rv;
+    if (mFileCache) {
+        rv = mDiskSpaceManager->AddCache(mFileCache);
+        if (NS_FAILED(rv)) return rv;
+    }
+    if (mFlatCache) {
+        rv = mDiskSpaceManager->AddCache(mFlatCache);
+        if (NS_FAILED(rv)) return rv;
+    }
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheManager::GetCachedNetData(const char *aUriSpec, const char *aSecondaryKey,
+                                 PRUint32 aSecondaryKeyLength,
+                                 PRUint32 aFlags, nsICachedNetData* *aResult)
+{
+    nsCachedNetData *cachedData;
+    nsresult rv;
+    nsINetDataCache *cache;
+    nsReplacementPolicy *spaceManager;
+
+    if (aFlags & CACHE_AS_FILE) {
+        cache = mFileCache;
+        spaceManager = mDiskSpaceManager;
+
+        // Ensure that cache is initialized
+        if (mDiskCacheCapacity == (PRUint32)-1)
+            return NS_ERROR_NOT_AVAILABLE;
+
+    } else if ((aFlags & BYPASS_PERSISTENT_CACHE) ||
+               (!mFileCache && !mFlatCache) || !mDiskCacheCapacity) {
+        cache = mMemCache;
+        spaceManager = mMemSpaceManager;
+    } else {
+        cache = mFlatCache ? mFlatCache : mFileCache;
+        spaceManager = mDiskSpaceManager;
+    }
+
+    // Construct the cache key by appending the secondary key to the URI spec
+    nsCAutoString cacheKey(aUriSpec);
+
+    // Insert NUL at end of URI spec
+    cacheKey += '\0';
+    if (aSecondaryKey)
+        cacheKey.Append(aSecondaryKey, aSecondaryKeyLength);
+
+    nsStringKey key(cacheKey);
+    cachedData = (nsCachedNetData*)mActiveCacheRecords->Get(&key);
+
+    // There is no existing instance of nsCachedNetData for this URL.
+    // Make one from the corresponding record in the cache module.
+    if (cachedData) {
+        NS_ASSERTION(cache == cachedData->mCache,
+                     "Cannot yet handle simultaneously active requests for the "
+                     "same URL using different caches");
+        NS_ADDREF(cachedData);
+    } else {
+        rv = spaceManager->GetCachedNetData(cacheKey.GetBuffer(), cacheKey.Length(),
+                                            cache, &cachedData);
+        if (NS_FAILED(rv)) return rv;
+
+        mActiveCacheRecords->Put(&key, cachedData);
+    }
+    
+    *aResult = cachedData;
+    return NS_OK;
+}
+
+// Remove this cache entry from the list of active ones
+nsresult
+nsCacheManager::NoteDormant(nsCachedNetData* aEntry)
+{
+    nsresult rv;
+    PRUint32 keyLength;
+    char* key;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    nsCachedNetData* deletedEntry;
+
+    rv = aEntry->GetRecord(getter_AddRefs(record));
+    if (NS_FAILED(rv)) return rv;
+    
+    rv = record->GetKey(&keyLength, &key);
+    if (NS_FAILED(rv)) return rv;
+    
+    nsStringKey hashTableKey(nsCString(key, keyLength));
+    deletedEntry = (nsCachedNetData*)gCacheManager->mActiveCacheRecords->Remove(&hashTableKey);
+//  NS_ASSERTION(deletedEntry == aEntry, "Hash table inconsistency");
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheManager::Contains(const char *aUriSpec, const char *aSecondaryKey,
+                         PRUint32 aSecondaryKeyLength,
+                         PRUint32 aFlags, PRBool *aResult)
+{
+    nsINetDataCache *cache;
+    nsReplacementPolicy *spaceManager;
+    nsCachedNetData *cachedData;
+
+    if (aFlags & CACHE_AS_FILE) {
+        cache = mFileCache;
+        spaceManager = mDiskSpaceManager;
+    } else if ((aFlags & BYPASS_PERSISTENT_CACHE) ||
+               (!mFileCache && !mFlatCache) || !mDiskCacheCapacity) {
+        cache = mMemCache;
+        spaceManager = mMemSpaceManager;
+    } else {
+        cache = mFlatCache ? mFlatCache : mFileCache;
+        spaceManager = mDiskSpaceManager;
+    }
+
+    // Construct the cache key by appending the secondary key to the URI spec
+    nsCAutoString cacheKey(aUriSpec);
+
+    // Insert NUL between URI spec and secondary key
+    cacheKey += '\0';
+    cacheKey.Append(aSecondaryKey, aSecondaryKeyLength);
+
+    // Locate the record using (URI + secondary key)
+    nsStringKey key(cacheKey);
+    cachedData = (nsCachedNetData*)mActiveCacheRecords->Get(&key);
+
+    if (cachedData && (cache == cachedData->mCache)) {
+        *aResult = PR_TRUE;
+        return NS_OK;
+    } else {
+        // No active cache entry, see if there is a dormant one
+        return cache->Contains(cacheKey.GetBuffer(), cacheKey.Length(), aResult);
+    }
+}
+
+NS_IMETHODIMP
+nsCacheManager::GetNumEntries(PRUint32 *aNumEntries)
+{
+    nsresult rv;
+    nsCOMPtr<nsISimpleEnumerator> iterator;
+    nsCOMPtr<nsISupports> cacheSupports;
+    nsCOMPtr<nsINetDataCache> cache;
+
+    PRUint32 totalEntries = 0;
+    
+    rv = NewCacheModuleIterator(getter_AddRefs(iterator));
+    if (NS_FAILED(rv)) return rv;
+    while (1) {
+        PRBool notDone;
+        rv = iterator->HasMoreElements(&notDone);
+        if (NS_FAILED(rv)) return rv;
+        if (!notDone)
+            break;
+        
+        iterator->GetNext(getter_AddRefs(cacheSupports));
+        cache = do_QueryInterface(cacheSupports);
+        
+        PRUint32 numEntries;
+        rv = cache->GetNumEntries(&numEntries);
+        if (NS_FAILED(rv)) return rv;
+        totalEntries += numEntries;
+    }
+    
+    *aNumEntries = totalEntries;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheManager::NewCacheEntryIterator(nsISimpleEnumerator* *aResult)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+class CacheEnumerator : public nsISimpleEnumerator
+{
+public:
+    CacheEnumerator(nsINetDataCache* aFirstCache):mCache(aFirstCache)
+        { NS_INIT_REFCNT(); }
+
+    virtual ~CacheEnumerator() {};
+    
+    NS_DECL_ISUPPORTS
+
+    NS_IMETHODIMP
+    HasMoreElements(PRBool* aMoreElements) {
+        *aMoreElements = (mCache != 0);
+        return NS_OK;
+    }
+
+    NS_IMETHODIMP
+    GetNext(nsISupports* *aSupports) {
+        *aSupports = mCache;
+        if (!mCache)
+            return NS_ERROR_FAILURE;
+        NS_ADDREF(*aSupports);
+
+        nsCOMPtr<nsINetDataCache> nextCache;
+        nsresult rv = mCache->GetNextCache(getter_AddRefs(nextCache));
+        mCache = nextCache;
+        return rv;
+    }
+
+private:
+    nsCOMPtr<nsINetDataCache> mCache;
+};
+
+NS_IMPL_ISUPPORTS(CacheEnumerator, NS_GET_IID(nsISimpleEnumerator))
+
+NS_IMETHODIMP
+nsCacheManager::NewCacheModuleIterator(nsISimpleEnumerator* *aResult)
+{
+    *aResult = new CacheEnumerator(mCacheSearchChain);
+    if (!*aResult)
+        return NS_ERROR_OUT_OF_MEMORY;
+    NS_ADDREF(*aResult);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheManager::RemoveAll(void)
+{
+    nsresult rv, result;
+    nsCOMPtr<nsISimpleEnumerator> iterator;
+    nsCOMPtr<nsINetDataCache> cache;
+    nsCOMPtr<nsISupports> iSupports;
+
+    result = NS_OK;
+    rv = NewCacheModuleIterator(getter_AddRefs(iterator));
+    if (NS_FAILED(rv)) return rv;
+    while (1) {
+        PRBool notDone;
+        rv = iterator->HasMoreElements(&notDone);
+        if (NS_FAILED(rv)) return rv;
+        if (!notDone)
+            break;
+        
+        iterator->GetNext(getter_AddRefs(iSupports));
+        cache = do_QueryInterface(iSupports);
+
+        PRUint32 cacheFlags;
+        rv = cache->GetFlags(&cacheFlags);
+        if (NS_FAILED(rv)) return rv;
+        
+        if ((cacheFlags & nsINetDataCache::READ_ONLY) == 0) {
+            rv = cache->RemoveAll();
+            if (NS_FAILED(rv))
+                result = rv;
+        }
+    }
+
+    return result;
+}
+
+nsresult
+nsCacheManager::LimitMemCacheSize()
+{
+    nsresult rv;
+    nsReplacementPolicy* spaceManager;
+
+    NS_ASSERTION(gCacheManager, "No cache manager");
+
+    spaceManager = gCacheManager->mMemSpaceManager;
+
+    PRUint32 occupancy;
+    rv = spaceManager->GetStorageInUse(&occupancy);
+    if (NS_FAILED(rv)) return rv;
+
+    PRUint32 memCacheCapacity = gCacheManager->mMemCacheCapacity;
+    if (occupancy > CACHE_HIGH_WATER_MARK(memCacheCapacity))
+        return spaceManager->Evict(CACHE_LOW_WATER_MARK(memCacheCapacity));
+
+    return NS_OK;
+}
+
+nsresult
+nsCacheManager::LimitDiskCacheSize()
+{
+    nsresult rv;
+    nsReplacementPolicy* spaceManager;
+
+    NS_ASSERTION(gCacheManager, "No cache manager");
+
+    spaceManager = gCacheManager->mDiskSpaceManager;
+
+    PRUint32 occupancy;
+    rv = spaceManager->GetStorageInUse(&occupancy);
+    if (NS_FAILED(rv)) return rv;
+
+    PRUint32 diskCacheCapacity = gCacheManager->mDiskCacheCapacity;
+    if (occupancy > CACHE_HIGH_WATER_MARK(diskCacheCapacity))
+        return spaceManager->Evict(CACHE_LOW_WATER_MARK(diskCacheCapacity));
+
+    return NS_OK;
+}
+
+nsresult
+nsCacheManager::LimitCacheSize()
+{
+    nsresult rv;
+
+    rv = LimitDiskCacheSize();
+    if (NS_FAILED(rv)) return rv;
+
+    rv = LimitMemCacheSize();
+    if (NS_FAILED(rv)) return rv;
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheManager::SetMemCacheCapacity(PRUint32 aCapacity)
+{
+    mMemCacheCapacity = aCapacity;
+    LimitCacheSize();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheManager::GetMemCacheCapacity(PRUint32* aCapacity)
+{
+    NS_ENSURE_ARG_POINTER(aCapacity);
+    *aCapacity = mMemCacheCapacity;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheManager::SetDiskCacheCapacity(PRUint32 aCapacity)
+{
+    mDiskCacheCapacity = aCapacity;
+    LimitCacheSize();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheManager::GetDiskCacheCapacity(PRUint32* aCapacity)
+{
+    NS_ENSURE_ARG_POINTER(aCapacity);
+    *aCapacity = mDiskCacheCapacity;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheManager::SetDiskCacheFolder(nsIFileSpec* aFolder)
+{
+    NS_ENSURE_ARG(aFolder);
+
+    if (!mFileCache)
+        return NS_ERROR_NOT_AVAILABLE;
+
+    nsCOMPtr<nsINetDataDiskCache> fileCache;
+    fileCache = do_QueryInterface(mFileCache);
+    return fileCache->SetDiskCacheFolder(aFolder);
+}
+
+NS_IMETHODIMP
+nsCacheManager::GetDiskCacheFolder(nsIFileSpec* *aFolder)
+{
+    NS_ENSURE_ARG(aFolder);
+
+    if (!mFileCache)
+        return NS_ERROR_NOT_AVAILABLE;
+
+    nsCOMPtr<nsINetDataDiskCache> fileCache;
+    fileCache = do_QueryInterface(mFileCache);
+    return fileCache->GetDiskCacheFolder(aFolder);
+}

mozilla/netwerk/cache/mgr/nsCacheManager.h

@@ -0,0 +1,100 @@
+/* -*- 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.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 Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *   Scott Furman, fur@netscape.com
+ */
+
+#ifndef _nsCacheManager_h_
+#define _nsCacheManager_h_
+
+// 2030f0b0-9567-11d3-90d3-0040056a906e
+#define NS_CACHE_MANAGER_CID                              \
+    {                                                     \
+        0x2030f0b0,                                       \
+        0x9567,                                           \
+        0x11d3,                                           \
+        {0x90, 0xd3, 0x00, 0x40, 0x05, 0x6a, 0x90, 0x6e}  \
+    }
+
+#include "nsINetDataCacheManager.h"
+#include "nsINetDataCache.h"
+#include "nsCOMPtr.h"
+
+class nsHashtable;
+class nsReplacementPolicy;
+class nsCachedNetData;
+
+class nsCacheManager : public nsINetDataCacheManager {
+
+public:
+    nsCacheManager();
+    virtual ~nsCacheManager();
+
+    NS_METHOD Init();
+
+    // nsISupports methods
+    NS_DECL_ISUPPORTS
+
+    // nsINetDataCacheManager methods
+    NS_DECL_NSINETDATACACHEMANAGER
+
+private:
+	
+    // Mapping from cache key to nsCachedNetData, but only for those cache
+    // entries with external references, i.e. those referred to outside the
+    // cache manager
+    nsHashtable*              mActiveCacheRecords;
+
+    // Memory cache
+    nsCOMPtr<nsINetDataCache> mMemCache;
+
+    // Flat-file database cache; All content aggregated into single disk file
+    nsCOMPtr<nsINetDataCache> mFlatCache;
+
+    // stream-as-file cache
+    nsCOMPtr<nsINetDataCache> mFileCache;
+
+    // Unified replacement policy for flat-cache and file-cache
+    nsReplacementPolicy*      mDiskSpaceManager;
+    
+    // Replacement policy for memory cache
+    nsReplacementPolicy*      mMemSpaceManager;
+
+    // List of caches in search order
+    nsINetDataCache*          mCacheSearchChain;
+
+    // Combined file/flat cache capacity, in KB
+    PRUint32                  mDiskCacheCapacity;
+
+    // Memory cache capacity, in KB
+    PRUint32                  mMemCacheCapacity;
+
+protected:
+    static nsresult NoteDormant(nsCachedNetData* aEntry);
+    static nsresult LimitCacheSize();
+    static nsresult LimitMemCacheSize();
+    static nsresult LimitDiskCacheSize();
+
+    friend class nsCachedNetData;
+    friend class CacheOutputStream;
+};
+
+#endif // _nsCacheManager_h_

mozilla/netwerk/cache/mgr/nsCachedNetData.h

@@ -0,0 +1,242 @@
+/* -*- 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.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 Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *   Scott Furman, fur@netscape.com
+ */
+
+#ifndef _nsCachedNetData_h_
+#define _nsCachedNetData_h_
+
+#include "nsICachedNetData.h"
+#include "nsCOMPtr.h"
+#include "nsINetDataCacheRecord.h"
+
+class nsINetDataCache;
+class nsIStreamAsFileObserver;
+class nsIStreamAsFile;
+class nsIArena;
+class StreamAsFileObserverClosure;
+class CacheMetaData;
+
+// Number of recent access times recorded
+#define MAX_K  3
+
+/**
+ * FIXME - add comment.  There are a lot of these data structures resident in
+ * memory, so be careful about adding members unnecessarily.
+ */
+class nsCachedNetData : public nsICachedNetData {
+
+public:
+    NS_DECL_ISUPPORTS
+
+    // nsICachedNetData methods
+    NS_DECL_NSICACHEDNETDATA
+
+    NS_METHOD Init(nsINetDataCacheRecord *aRecord, nsINetDataCache *aCache);
+
+protected:
+
+    // Bits for mFlags, below
+    typedef enum {
+        DIRTY               = 1 << 0, // Cache entry data needs to be flushed to database
+
+    // ==== Flags that can be set by the protocol handler ====
+        ALLOW_PARTIAL       = 1 << 1, // Protocol handler supports partial fetching
+        UPDATE_IN_PROGRESS  = 1 << 2, // Protocol handler now modifying cache data
+
+    // ==== Cache-entry state flags.  At most one of these flags can be set ====
+        TRUNCATED_CONTENT   = 1 << 4, // Entry contains valid content, but it has
+                                      //   been truncated by cache manager
+
+        // A previously-used cache entry, which has been purged of all cached
+        // content and protocol-private data.  This cache entry can be refilled
+        // with new content or it may be retained in this vestigial state
+        // because the usage statistics it contains will be used by the
+        // replacement policy if the same URI is ever cached again.
+        VESTIGIAL           = 1 << 5,
+
+    // ==== Memory usage status bits.  At most one of these flags can be set ====
+        RECYCLED            = 1 << 8, // Previously associated database record has
+                                      //   been deleted; This cache entry is available
+                                      //   for recycling.
+
+        DORMANT             = 1 << 9, // No references to this cache entry, except by
+                                      //   the cache manager itself
+        
+    // ==== Setter bits ====
+        LAST_MODIFIED_KNOWN = 1 <<12, // Protocol handler called SetLastModifiedTime()
+        EXPIRATION_KNOWN    = 1 <<13, // Protocol handler called SetExpirationTime()
+        STALE_TIME_KNOWN    = 1 <<14, // Protocol handler called SetStaleTime()
+
+    // ==== Useful flag combinations ====
+        // Cache entry not eligible for eviction
+        UNEVICTABLE         = VESTIGIAL | RECYCLED | UPDATE_IN_PROGRESS,
+        
+        // State flags that are in-memory only, i.e. not persistent 
+        TRANSIENT_FLAGS     = DIRTY | RECYCLED | DORMANT
+    } Flag;
+
+    PRBool GetFlag(Flag aFlag) { return (mFlags & aFlag) != 0; }
+    nsresult GetFlag(PRBool *aResult, Flag aFlag) { *aResult = GetFlag(aFlag); return NS_OK; }
+
+    // Set a boolean flag for the cache entry
+    nsresult SetFlag(PRBool aValue, Flag aFlag);
+    nsresult SetFlag(Flag aFlag)   { return SetFlag(PR_TRUE,  aFlag); }
+    nsresult ClearFlag(Flag aFlag) { return SetFlag(PR_FALSE, aFlag); }
+
+    void ComputeProfit(PRUint32 aCurrentTime);
+    static int Compare(const void *a, const void *b, void *unused);
+
+    void NoteAccess();
+    void NoteUpdate();
+
+    // Get underlying raw cache database record.
+    nsresult GetRecord(nsINetDataCacheRecord* *aRecord);
+
+    nsresult GetRecordID(PRInt32 *aRecordID);
+
+    nsresult Evict(PRUint32 aTruncatedContentLength);
+    
+    nsresult GetFileSpec(nsIFileSpec* *aFileSpec);
+
+    void NoteDownloadTime(PRTime start, PRTime end);
+
+    // placement new for arena-allocation
+    void *operator new (size_t aSize, nsIArena *aArena);
+
+    friend class nsReplacementPolicy;
+    friend class nsCacheManager;
+    friend class StreamAsFile;
+    friend class nsCacheEntryChannel;
+    friend class CacheOutputStream;
+    friend class InterceptStreamListener;
+
+private:
+
+    nsCachedNetData() {};
+    virtual ~nsCachedNetData() {};
+
+    // Initialize internal fields of this nsCachedNetData instance from the
+    // underlying raw cache database record.
+    nsresult Deserialize(PRBool aDeserializeFlags);
+
+    // Notify stream-as-file observers about change in cache entry status
+    nsresult Notify(PRUint32 aMessage, nsresult aError);
+
+    // Add/Remove stream-as-file observers
+    nsresult AddObserver(nsIStreamAsFile *aStreamAsFile, nsIStreamAsFileObserver* aObserver);
+    nsresult RemoveObserver(nsIStreamAsFileObserver* aObserver);
+
+    // Mark cache entry to indicate a write out to the cache database is required
+    void SetDirty() { mFlags |= DIRTY; }
+
+    nsresult Resurrect(nsINetDataCacheRecord *aRecord);
+
+    nsresult CommitFlags();
+
+    CacheMetaData* FindTaggedMetaData(const char* aTag, PRBool aCreate);
+
+private:
+    
+    // List of nsIStreamAsFileObserver's that will receive notification events
+    // when the cache manager or a client desires to delete/truncate a cache
+    // entry file.
+    StreamAsFileObserverClosure* mObservers;
+
+    // Protocol-specific meta-data, opaque to the cache manager
+    CacheMetaData *mMetaData;
+
+    // Next in chain for a single bucket in the replacement policy hash table
+    // that maps from record ID to nsCachedNetData
+    nsCachedNetData* mNext;
+    
+    // See flag bits, above
+    // NOTE: 16 bit member is combined with members below for
+    //       struct packing efficiency.  Do not change order of members!
+    PRUint16    mFlags;
+
+protected:
+
+    // Number of nsCacheEntryChannels referring to this record
+    PRUint8     mChannelCount;
+
+    // Below members are statistics kept per cache-entry, used to decide how
+    // profitable it will be to evict a record from the cache relative to other
+    // existing records.  Note: times are measured in *seconds* since the
+    // 1/1/70 epoch, same as a unix time_t.
+
+    // Number of accesses for this cache record
+    // NOTE: 8 bit member is combined with members above for
+    //       struct packing efficiency.  Do not change order of members!
+    PRUint8     mNumAccesses;
+
+    // A reference to the underlying, raw cache database record, either as a
+    // pointer to an in-memory object or as a database record identifier
+    union {
+        nsINetDataCacheRecord* mRecord;
+
+        // Database record ID of associated cache record.  See
+        // nsINetDataCache::GetRecordByID().
+        PRInt32  mRecordID;
+    };
+
+    // Weak link to parent cache
+    nsINetDataCache* mCache;
+
+    // Length of stored content, which may be less than storage consumed if
+    // compression is used
+    PRUint32 mLogicalLength;
+
+    // Most recent cache entry access times, used to compute access frequency
+    PRUint32 mAccessTime[MAX_K];
+    
+    // We use modification time of the original document for replacement policy
+    // computations, i.e. to compute a document's age, but if we don't know it,
+    // we use the time that the document was last written to the cache.
+    union {
+        // Document modification time, if known.
+        PRUint32 mLastModifiedTime;
+
+        // Time of last cache update for this doc
+        PRUint32 mLastUpdateTime;
+    };
+
+    union {
+      // Time until which document is fresh, i.e. does not have to be validated
+      // with server and, therefore, data in cache is guaranteed usable
+      PRUint32 mExpirationTime;
+
+      // Heuristic time at which cached document is likely to be out-of-date
+      // with respect to canonical copy on server.  Used for cache replacement
+      // policy, not for validation.
+      PRUint32 mStaleTime;
+    };
+
+    // Download time per byte, measure roughly in units of KB/s
+    float mDownloadRate;
+    
+    // Heuristic estimate of cache entry future benefits, based on above values
+    float mProfit;
+};
+
+#endif // _nsCachedNetData_h_
+

mozilla/netwerk/cache/mgr/nsReplacementPolicy.cpp

@@ -0,0 +1,666 @@
+/* -*- 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.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 Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *   Scott Furman, fur@netscape.com
+ */
+
+#include "nsReplacementPolicy.h"
+#include "nsCachedNetData.h"
+
+#include "nsQuickSort.h"
+#include "nsIAllocator.h"
+#include "nsIEnumerator.h"
+#include "prtime.h"
+#include "prbit.h"
+#include "nsCOMPtr.h"
+#include <math.h>
+
+// Constant used to estimate frequency of access to a document based on size
+#define CACHE_CONST_B   1.35
+
+// A cache whose space is managed by this replacement policy
+class nsReplacementPolicy::CacheInfo {
+public:
+    CacheInfo(nsINetDataCache* aCache):mCache(aCache),mNext(0) {}
+
+    nsINetDataCache* mCache;
+    CacheInfo*       mNext;
+};
+
+nsReplacementPolicy::nsReplacementPolicy()
+    : mRankedEntries(0), mCaches(0), mRecordsRemovedSinceLastRanking(0),
+      mNumEntries(0), mCapacityRankedEntriesArray(0), mLastRankTime(0) {}
+
+nsReplacementPolicy::~nsReplacementPolicy()
+{
+    if (mRankedEntries)
+        nsAllocator::Free(mRankedEntries);
+    if (mMapRecordIdToEntry)
+        nsAllocator::Free(mMapRecordIdToEntry);
+}
+
+nsresult
+nsReplacementPolicy::Init(PRUint32 aMaxCacheEntries)
+{
+    nsresult rv;
+
+    rv = NS_NewHeapArena(getter_AddRefs(mArena), sizeof(nsCachedNetData) * 32);
+    if (NS_FAILED(rv)) return rv;
+
+    mMaxEntries = aMaxCacheEntries;
+
+    mHashArrayLength = PR_CeilingLog2(aMaxCacheEntries) >> 3;
+    size_t numBytes = mHashArrayLength * sizeof(*mMapRecordIdToEntry);
+    mMapRecordIdToEntry = (nsCachedNetData**)nsAllocator::Alloc(numBytes);
+    if (!mMapRecordIdToEntry)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    nsCRT::zero(mMapRecordIdToEntry, numBytes);
+
+    return NS_OK;
+}
+
+nsresult
+nsReplacementPolicy::AddCache(nsINetDataCache *aCache)
+{
+    CacheInfo *cacheInfo = new CacheInfo(aCache);
+    if (!cacheInfo)
+        return NS_ERROR_OUT_OF_MEMORY;
+    cacheInfo->mNext = mCaches;
+    mCaches = cacheInfo;
+    return NS_OK;
+}
+
+PRUint32
+nsReplacementPolicy::HashRecordID(PRInt32 aRecordID)
+{
+    return ((aRecordID >> 16) ^ aRecordID) & (mHashArrayLength - 1);
+}
+
+nsCachedNetData*
+nsReplacementPolicy::FindCacheEntryByRecordID(PRInt32 aRecordID, nsINetDataCache *aCache)
+{
+    nsresult rv;
+    nsCachedNetData* cacheEntry;
+    PRUint32 bucket = HashRecordID(aRecordID);
+
+    cacheEntry = mMapRecordIdToEntry[bucket];
+    for (;cacheEntry; cacheEntry = cacheEntry->mNext) {
+
+        PRInt32 recordID;
+        rv = cacheEntry->GetRecordID(&recordID);
+        if (NS_FAILED(rv))
+            continue;
+
+        if ((recordID == aRecordID) && (cacheEntry->mCache == aCache))
+            return cacheEntry;
+    }
+
+    return 0;
+}
+
+// Add a cache entry to the hash table that maps record ID to entries
+void
+nsReplacementPolicy::AddCacheEntry(nsCachedNetData* aCacheEntry, PRInt32 aRecordID)
+{
+    nsCachedNetData** cacheEntryp;
+    PRUint32 bucket = HashRecordID(aRecordID);
+
+    cacheEntryp = &mMapRecordIdToEntry[bucket];
+    while (*cacheEntryp)
+        cacheEntryp = &(*cacheEntryp)->mNext;
+    *cacheEntryp = aCacheEntry;
+    aCacheEntry->mNext = 0;
+}
+
+// Delete a cache entry from the hash table that maps record ID to entries
+nsresult
+nsReplacementPolicy::DeleteCacheEntry(nsCachedNetData* aCacheEntry)
+{
+    nsresult rv;
+    PRInt32 recordID;
+    rv = aCacheEntry->GetRecordID(&recordID);
+    if (NS_FAILED(rv)) return rv;
+
+    PRUint32 bucket = HashRecordID(recordID);
+
+    nsCachedNetData** cacheEntryp;
+    cacheEntryp = &mMapRecordIdToEntry[bucket];
+    while (*cacheEntryp) {
+        if (*cacheEntryp == aCacheEntry) {
+            *cacheEntryp = aCacheEntry->mNext;
+            return NS_OK;
+        }
+        cacheEntryp = &(*cacheEntryp)->mNext;
+    }
+    
+    NS_ASSERTION(0, "hash table inconsistency");
+    return NS_ERROR_FAILURE;
+}
+
+nsresult
+nsReplacementPolicy::AddAllRecordsInCache(nsINetDataCache *aCache)
+{
+    nsresult rv;
+    nsCOMPtr<nsISimpleEnumerator> iterator;
+    nsCOMPtr<nsISupports> iSupports;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    rv = aCache->NewCacheEntryIterator(getter_AddRefs(iterator));
+    if (!NS_SUCCEEDED(rv)) return rv;
+
+    while (1) {
+        PRBool notDone;
+
+        rv = iterator->HasMoreElements(&notDone);
+        if (NS_FAILED(rv)) return rv;
+        if (!notDone)
+            break;
+
+        rv = iterator->GetNext(getter_AddRefs(iSupports));
+        if (!NS_SUCCEEDED(rv)) return rv;
+        record = do_QueryInterface(iSupports);
+        
+        rv = AssociateCacheEntryWithRecord(record, aCache, 0);
+        if (!NS_SUCCEEDED(rv)) return rv;
+    }
+
+    return NS_OK;
+}
+
+// Get current time and convert to seconds since the epoch
+static PRUint32
+now32()
+{
+    double nowFP;
+    PRInt64 now64 = PR_Now();
+    LL_L2D(nowFP, now64);
+    PRUint32 now = (PRUint32)(nowFP * 1e-6);
+    return now;
+}
+
+void
+nsCachedNetData::NoteDownloadTime(PRTime start, PRTime end)
+{
+    double startFP, endFP, rate, duration;
+
+    LL_L2D(startFP, start);
+    LL_L2D(endFP, end);
+
+    duration = endFP - startFP;
+
+    // If the data arrives so fast that it can not be timed due to the clock
+    // granularity, assume a data arrival duration of 10 ms
+    if (!duration)
+        duration = 10000;
+
+    // Compute download rate in kB/s
+    rate = mLogicalLength / (duration * (1e-6 * 1024.0));
+    
+    if (mDownloadRate) {
+        // Exponentially smooth download rate
+        const double alpha = 0.5;
+        mDownloadRate = (float)(mDownloadRate * alpha + rate * (1.0 - alpha));
+    } else {
+        mDownloadRate = (float)rate;
+    }
+}
+
+// 1 hour
+#define MIN_HALFLIFE (60 * 60)
+
+// 1 week
+#define TYPICAL_HALFLIFE (7 * 24 * 60 * 60)
+
+/**
+ * Estimate the profit that would be lost if the given cache entry was evicted
+ * from the cache.  Profit is defined as the future expected download delay per
+ * byte of cached content.  The profit computation is made based on projected
+ * frequency of access, prior download performance and a heuristic staleness
+ * criteria.  The technique used is a variation of that described in the
+ * following paper:
+ *
+ *    "A Case for Delay-Conscious Caching of Web Documents"
+ *    http://www.bell-labs.com/user/rvingral/www97.html
+ *
+ * Briefly, expected profit is:
+ *
+ *   (projected frequency of access) * (download time per byte) * (probability freshness)
+ */
+void
+nsCachedNetData::ComputeProfit(PRUint32 aNow)
+{
+    PRUint32 K, now;
+
+    if (aNow)
+        now = aNow;
+    else
+        now = now32();
+    
+    K = PR_MIN(MAX_K, mNumAccesses);
+    if (!K) {
+        mProfit = 0;
+        return;
+    }
+
+    // Compute time, in seconds, since k'th most recent access
+    double timeSinceKthAccess = now - mAccessTime[K - 1];
+    if (timeSinceKthAccess <= 0.0)    // Sanity check
+        timeSinceKthAccess = 1.0;
+
+    // Estimate frequency of future document access based on past
+    //  access frequency
+    double frequencyAccess = K / timeSinceKthAccess;
+
+    // If we don't have much historical data on access frequency
+    //   use a heuristic based on document size as an estimate
+    if (mLogicalLength) {
+        if (K == 1) {
+            frequencyAccess /= pow(mLogicalLength, CACHE_CONST_B);
+        } else if (K == 2) {
+            frequencyAccess /= pow(mLogicalLength, CACHE_CONST_B / 2);
+        }
+    }
+
+    // Estimate likelihood that data in cache is fresh, i.e.
+    //  that it corresponds to the document on the server
+    double probabilityFreshness;
+    PRInt32 halfLife, age, docTime;
+    PRBool potentiallyStale;
+
+    docTime = GetFlag(LAST_MODIFIED_KNOWN) ? mLastModifiedTime : mLastUpdateTime;
+    age = now - docTime;
+
+    probabilityFreshness = 1.0; // Optimistic
+
+    if (GetFlag(EXPIRATION_KNOWN)) {
+        potentiallyStale = now > mExpirationTime;
+        halfLife = mExpirationTime - mLastModifiedTime;
+    } else if (GetFlag(STALE_TIME_KNOWN)) {
+        potentiallyStale = PR_TRUE;
+        halfLife = mStaleTime - docTime;
+    } else {
+        potentiallyStale = PR_TRUE;
+        halfLife = TYPICAL_HALFLIFE;
+    }
+    
+    if (potentiallyStale) {
+        if (halfLife < MIN_HALFLIFE)
+            halfLife = MIN_HALFLIFE;
+
+        probabilityFreshness = pow(0.5, (double)age / (double)halfLife);
+    }
+
+    mProfit = (float)(frequencyAccess * probabilityFreshness);
+    if (mDownloadRate)
+        mProfit /= mDownloadRate;
+}
+
+// Number of entries to grow mRankedEntries array when it's full
+#define STATS_GROWTH_INCREMENT  256
+
+
+// Sorting predicate for NS_Quicksort
+int
+nsCachedNetData::Compare(const void *a, const void *b, void *unused)
+{
+    nsCachedNetData* entryA = *(nsCachedNetData**)a;
+    nsCachedNetData* entryB = *(nsCachedNetData**)b;
+
+    // Percolate deleted or empty entries to the end of the mRankedEntries
+    // array, so that they can be recycled.
+    if (!entryA || entryA->GetFlag(RECYCLED)) {
+        if (!entryB || entryB->GetFlag(RECYCLED))
+            return 0;
+        else 
+            return +1;
+    } 
+    if (!entryB || entryB->GetFlag(RECYCLED))
+        return -1;
+
+    // Evicted entries (those with no content data) and active entries (those
+    // currently being updated) are collected towards the end of the sorted
+    // array just prior to the deleted cache entries, since evicted entries
+    // can't be re-evicted.
+    if (entryA->GetFlag(UPDATE_IN_PROGRESS)) {
+        if (entryB->GetFlag(UPDATE_IN_PROGRESS))
+            return 0;
+        else 
+            return +1;
+    } 
+    if (entryB->GetFlag(UPDATE_IN_PROGRESS))
+        return -1;
+
+    PRUint16 Ka = PR_MIN(MAX_K, entryA->mNumAccesses);
+    PRUint16 Kb = PR_MIN(MAX_K, entryB->mNumAccesses);
+
+    // Order cache entries by the number of times they've been accessed
+    if (Ka < Kb)
+        return -1;
+    if (Ka > Kb)
+        return +1;
+
+    /*
+     * Among records that have been accessed an equal number of times, order
+     * them by profit.
+     */
+    if (entryA->mProfit > entryB->mProfit)
+        return +1;
+    if (entryA->mProfit < entryB->mProfit)
+        return -1;
+    return 0;
+}
+
+/**
+ * Rank cache entries in terms of their elegibility for eviction.
+ */
+nsresult
+nsReplacementPolicy::RankRecords()
+{
+    PRUint32 i, now;
+
+    // Add all cache records if this is the first ranking
+    if (!mLastRankTime) {
+        nsresult rv;
+        CacheInfo *cacheInfo;
+
+        cacheInfo = mCaches;
+        while (cacheInfo) {
+            rv = AddAllRecordsInCache(cacheInfo->mCache);
+            if (NS_FAILED(rv)) return rv;
+
+            cacheInfo = cacheInfo->mNext;
+        }
+    }
+
+    // Get current time and convert to seconds since the epoch
+    now = now32();
+
+    // Recompute profit for every known cache record, except deleted ones
+    for (i = 0; i < mNumEntries; i++) {
+        nsCachedNetData* entry = mRankedEntries[i];
+        if (entry && !entry->GetFlag(nsCachedNetData::RECYCLED))
+            entry->ComputeProfit(now);
+    }
+    NS_QuickSort(mRankedEntries, mNumEntries, sizeof *mRankedEntries, 
+                 nsCachedNetData::Compare, 0);
+
+    mNumEntries -= mRecordsRemovedSinceLastRanking;
+    mRecordsRemovedSinceLastRanking = 0;
+    mLastRankTime = now;
+    return NS_OK;
+}
+
+// A heuristic policy to avoid the cost of re-ranking cache records by
+// profitability every single time space must be made available in the cache.
+void
+nsReplacementPolicy::MaybeRerankRecords()
+{
+    // Rank at most once per minute
+    PRUint32 now = now32();
+    if ((now - mLastRankTime) >= 60)
+        RankRecords();
+}
+
+void
+nsReplacementPolicy::CompactRankedEntriesArray()
+{
+    if (mRecordsRemovedSinceLastRanking || !mLastRankTime)
+        RankRecords();
+}
+
+nsresult
+nsReplacementPolicy::CheckForTooManyCacheEntries()
+{
+    if (mCapacityRankedEntriesArray == mMaxEntries) {
+        return DeleteOneEntry(0);
+    } else {
+        nsresult rv;
+        CacheInfo *cacheInfo;
+
+        cacheInfo = mCaches;
+        while (cacheInfo) {
+            PRUint32 numEntries, maxEntries;
+
+            rv = cacheInfo->mCache->GetNumEntries(&numEntries);
+            if (NS_FAILED(rv)) return rv;
+
+            rv = cacheInfo->mCache->GetMaxEntries(&maxEntries);
+            if (NS_FAILED(rv)) return rv;
+
+            if (numEntries == maxEntries)
+                return DeleteOneEntry(cacheInfo->mCache);
+
+            cacheInfo = cacheInfo->mNext;
+        }
+    }
+    return NS_OK;
+}
+
+
+/** 
+ * Create a new association between a low-level cache database record and a
+ * cache entry.  Add the entry to the set of entries eligible for eviction from
+ * the cache.  This would typically be done when the cache entry is created.
+ */
+nsresult
+nsReplacementPolicy::AssociateCacheEntryWithRecord(nsINetDataCacheRecord *aRecord,
+                                                   nsINetDataCache* aCache,
+                                                   nsCachedNetData** aResult)
+{
+    nsCachedNetData* cacheEntry;
+    nsresult rv;
+
+    // First, see if the record is already known to the replacement policy
+    PRInt32 recordID;
+    rv = aRecord->GetRecordID(&recordID);
+    if (NS_FAILED(rv)) return rv;
+    cacheEntry = FindCacheEntryByRecordID(recordID, aCache);
+    if (cacheEntry) {
+        if (aResult) {
+            if (cacheEntry->GetFlag(nsCachedNetData::DORMANT))
+                cacheEntry->Resurrect(aRecord);
+            NS_ADDREF(cacheEntry);
+            *aResult = cacheEntry;
+        }
+        return NS_OK;
+    }
+
+    // Compact the array of cache entry statistics, so that free entries appear
+    // at the end, for possible reuse.
+    if (mNumEntries && (mNumEntries == mCapacityRankedEntriesArray))
+        CompactRankedEntriesArray();
+
+    // If compaction doesn't yield available entries in the
+    // mRankedEntries array, then extend the array.
+    if (mNumEntries == mCapacityRankedEntriesArray) {
+        PRUint32 newCapacity;
+
+        rv = CheckForTooManyCacheEntries();
+        if (NS_FAILED(rv)) return rv;
+
+        newCapacity = mCapacityRankedEntriesArray + STATS_GROWTH_INCREMENT;
+        if (newCapacity > mMaxEntries)
+            newCapacity = mMaxEntries;
+
+        nsCachedNetData** newRankedEntriesArray; 
+        PRUint32 numBytes = sizeof(nsCachedNetData*) * newCapacity;
+        newRankedEntriesArray = 
+            (nsCachedNetData**)nsAllocator::Realloc(mRankedEntries, numBytes);
+        if (!newRankedEntriesArray)
+            return NS_ERROR_OUT_OF_MEMORY;
+        
+        mRankedEntries = newRankedEntriesArray;
+        mCapacityRankedEntriesArray = newCapacity;
+
+        PRUint32 i;
+        for (i = mNumEntries; i < newCapacity; i++)
+            mRankedEntries[i] = 0;
+    }
+
+    // Recycle the record after the last in-use record in the array
+    nsCachedNetData *entry = mRankedEntries[mNumEntries];
+    NS_ASSERTION(!entry || !entry->GetFlag(nsCachedNetData::RECYCLED),
+                 "Only deleted cache entries should appear at end of array");
+
+    if (!entry) {
+        entry = new(mArena) nsCachedNetData;
+        if (!entry)
+            return NS_ERROR_OUT_OF_MEMORY;
+        mRankedEntries[mNumEntries] = entry;
+    } else {
+        // Clear out recycled data structure
+        nsCRT::zero(entry, sizeof(*entry));
+    }
+
+    entry->Init(aRecord, aCache);
+    AddCacheEntry(entry, recordID);
+    
+    // Add one reference to the cache entry from the cache manager
+    NS_ADDREF(entry);
+
+    if (aResult) {
+        // And one reference from our caller
+        NS_ADDREF(entry);
+        *aResult = entry;
+    }
+
+    mNumEntries++;
+    return NS_OK;
+}
+
+nsresult
+nsReplacementPolicy::GetCachedNetData(const char* cacheKey, PRUint32 cacheKeyLength,
+                                      nsINetDataCache* aCache,
+                                      nsCachedNetData** aResult)
+{
+    nsresult rv;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+
+    rv = aCache->GetCachedNetData(cacheKey, cacheKeyLength,
+                                  getter_AddRefs(record));
+    if (NS_FAILED(rv)) return rv;
+    return AssociateCacheEntryWithRecord(record, aCache, aResult);
+}
+
+/**
+ * Delete the least desirable record from the cache database.  This is used
+ * when the addition of another record would exceed either the cache manager or
+ * the cache's maximum permitted number of records.
+ */
+nsresult
+nsReplacementPolicy::DeleteOneEntry(nsINetDataCache *aCache)
+{
+    PRUint32 i;
+    nsresult rv;
+    nsCachedNetData *entry;
+
+    i = 0;
+    while (1) {
+        MaybeRerankRecords();
+        for (; i < mNumEntries; i++) {
+            entry = mRankedEntries[i];
+            if (!entry || entry->GetFlag(nsCachedNetData::RECYCLED))
+                continue;
+            if (!aCache || (entry->mCache == aCache))
+                break;
+        }
+
+        // Report error if no record found to delete
+        if (i == mNumEntries)
+            return NS_ERROR_FAILURE;
+        rv = entry->Delete();
+        if (NS_SUCCEEDED(rv)) {
+            rv = DeleteCacheEntry(entry);
+            return rv;
+        }
+    }
+}
+
+nsresult
+nsReplacementPolicy::GetStorageInUse(PRUint32* aStorageInUse)
+{
+    nsresult rv;
+    CacheInfo *cacheInfo;
+
+    *aStorageInUse = 0;
+    cacheInfo = mCaches;
+    while (cacheInfo) {
+        PRUint32 cacheStorage;
+        rv = cacheInfo->mCache->GetStorageInUse(&cacheStorage);
+        if (NS_FAILED(rv)) return rv;
+
+        *aStorageInUse += cacheStorage;
+        cacheInfo = cacheInfo->mNext;
+    }
+    return NS_OK;
+}
+
+/**
+ * Delete the least desirable records from the cache until the occupancy of the
+ * cache has been reduced by the given number of KB.  This is used when the
+ * addition of more cache data would exceed the cache's capacity. 
+ */
+nsresult
+nsReplacementPolicy::Evict(PRUint32 aTargetOccupancy)
+{
+    PRUint32 i;
+    nsCachedNetData *entry;
+    nsresult rv;
+    PRUint32 occupancy;
+    PRInt32 truncatedLength;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+
+    MaybeRerankRecords();
+    for (i = 0; i < mNumEntries; i++) {
+        rv = GetStorageInUse(&occupancy);
+        if (!NS_SUCCEEDED(rv)) return rv;
+        
+        if (occupancy <= aTargetOccupancy)
+            return NS_OK;
+
+        entry = mRankedEntries[i];
+
+        // Skip deleted/empty cache entries and ones that have already been evicted
+        if (!entry || entry->GetFlag(nsCachedNetData::UNEVICTABLE))
+            continue;
+
+        if (entry->GetFlag(nsCachedNetData::ALLOW_PARTIAL)) {
+            rv = entry->GetRecord(getter_AddRefs(record));
+            if (NS_FAILED(rv))
+                continue;
+
+            PRUint32 contentLength;
+            rv = record->GetStoredContentLength(&contentLength);
+            if (NS_FAILED(rv))
+                continue;
+            
+            // Additional cache storage required, in KB
+            PRUint32 storageToReclaim = (occupancy - aTargetOccupancy) << 10;
+            
+            truncatedLength = (PRInt32)(contentLength - storageToReclaim);
+            if (truncatedLength < 0)
+                truncatedLength = 0;
+        } else {
+            truncatedLength = 0;
+        }
+        rv = entry->Evict(truncatedLength);
+    }
+    return NS_ERROR_FAILURE;
+}

mozilla/netwerk/cache/mgr/nsReplacementPolicy.h

@@ -0,0 +1,136 @@
+/* -*- 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.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 Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *   Scott Furman, fur@netscape.com
+ */
+
+/**
+ * This class manages one or more caches that share a storage resource, e.g. a
+ * file cache and a flat-database cache might each occupy space on the disk and
+ * they would share a single instance of nsReplacementPolicy.  The replacement
+ * policy heuristically chooses which cache entries to evict when storage is
+ * required to accommodate incoming cache data.
+ */
+
+#ifndef _nsReplacementPolicy_h_
+#define _nsReplacementPolicy_h_
+
+#include "nscore.h"
+#include "nsISupportsUtils.h"
+#include "nsINetDataCache.h"
+#include "nsICachedNetData.h"
+#include "nsIArena.h"
+#include "nsCOMPtr.h"
+#include "nsHashtable.h"
+
+class nsCachedNetData;
+struct PL_HashTable;
+
+/**
+ * This private class is responsible for implementing the network data cache's
+ * replacement policy, i.e. it decides which cache data should be evicted to
+ * make room for new incoming data.
+ */
+class nsReplacementPolicy {
+
+public:
+
+    nsReplacementPolicy();
+    ~nsReplacementPolicy();
+
+protected:
+
+    nsresult Init(PRUint32 aMaxCacheEntries);
+    nsresult AddCache(nsINetDataCache *aCache);
+    nsresult GetCachedNetData(const char* cacheKey, PRUint32 cacheKeyLength,
+                              nsINetDataCache* aCache,
+                              nsCachedNetData** aResult);
+    nsresult GetStorageInUse(PRUint32* aNumKBytes);
+
+    friend class nsCacheManager;
+
+private:
+    nsresult RankRecords();
+    void MaybeRerankRecords();
+    void CompactRankedEntriesArray();
+    nsresult DeleteOneEntry(nsINetDataCache* aCache);
+    nsresult Evict(PRUint32 aTargetOccupancy);
+
+    nsCachedNetData* FindCacheEntryByRecordID(PRInt32 aRecordID, nsINetDataCache *aCache);
+    void AddCacheEntry(nsCachedNetData* aCacheEntry, PRInt32 aRecordID);
+    nsresult DeleteCacheEntry(nsCachedNetData* aCacheEntry);
+    PRUint32 HashRecordID(PRInt32 aRecordID);
+    nsresult AssociateCacheEntryWithRecord(nsINetDataCacheRecord *aRecord,
+                                           nsINetDataCache* aCache,
+                                           nsCachedNetData** aResult);
+
+    nsresult AddAllRecordsInCache(nsINetDataCache *aCache);
+    nsresult CheckForTooManyCacheEntries();
+
+    class CacheInfo;
+
+private:
+
+    // Growable array of pointers to individual cache entries; It is sorted by
+    // profitability, such that low-numbered array indices refer to cache
+    // entries that are the least profitable to retain.  New cache entries are
+    // added to the end of the array.  Deleted cache entries are specially
+    // marked and percolate to the end of the array for recycling whenever
+    // mRankedEntries is sorted.  Evicted cache entries (those with no
+    // associated content data) are retained for the purpose of improving the
+    // replacement policy efficacy, and are percolated towards the end of the
+    // array, just prior to the deleted cache entries.
+    //
+    // The array is not in sorted order 100% of the time; For efficiency
+    // reasons, sorting is only done when heuristically deemed necessary.
+    nsCachedNetData**   mRankedEntries;
+
+    // Hash table buckets to map Record ID to cache entry.  We use this instead
+    // of a PL_HashTable to reduce storage requirements
+    nsCachedNetData**   mMapRecordIdToEntry;
+
+    // Length of mMapRecordIdToEntry array
+    PRUint32            mHashArrayLength;
+
+    // Linked list of caches that share this replacement policy
+    CacheInfo*          mCaches;
+
+    // Allocation area for cache entry (nsCachedNetData) instances
+    nsCOMPtr<nsIArena>  mArena;
+
+    // Bookkeeping
+    PRUint32            mRecordsRemovedSinceLastRanking;
+
+    // Maximum permitted length of mRankedEntries array
+    PRUint32            mMaxEntries;
+
+    // Number of occupied slots in mRankedEntries array
+    PRUint32            mNumEntries;
+
+    // Capacity of mRankedEntries array
+    PRUint32            mCapacityRankedEntriesArray;
+
+    // Time at which cache entries were last ranked by profitability
+    PRUint32            mLastRankTime;
+};
+
+
+#endif // _nsReplacementPolicy_h_

mozilla/netwerk/cache/public/Makefile.in

@@ -0,0 +1,43 @@
+#
+# 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@
+
+MODULE		= nkcache
+
+include $(DEPTH)/config/autoconf.mk
+
+XPIDLSRCS	= \
+		nsICachedNetData.idl          \
+	        nsINetDataCacheManager.idl    \
+		nsINetDataCache.idl           \
+		nsINetDataCacheRecord.idl     \
+	        nsINetDataDiskCache.idl       \
+		nsIStreamAsFile.idl           \
+	        $(NULL)
+
+EXPORTS		:= $(addprefix $(srcdir)/, $(EXPORTS))
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/netwerk/cache/public/Makefile.win

@@ -0,0 +1,41 @@
+#!gmake
+#
+# 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): 
+
+MODULE = nkcache
+
+DEPTH = ..\..\..
+include <$(DEPTH)/config/config.mak>
+
+
+EXPORTS =                   \
+        $(NULL)
+
+XPIDLSRCS =                             \
+        .\nsICachedNetData.idl          \
+        .\nsINetDataCacheManager.idl    \
+        .\nsINetDataCache.idl           \
+        .\nsINetDataCacheRecord.idl     \
+        .\nsINetDataDiskCache.idl       \
+        .\nsIStreamAsFile.idl           \
+        $(NULL)
+
+include <$(DEPTH)/config/rules.mak>
+

mozilla/netwerk/cache/public/nsICachedNetData.idl

@@ -0,0 +1,229 @@
+/* -*- 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.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): 
+ */
+
+#include "nsrootidl.idl"
+#include "nsISupports.idl"
+
+interface nsIFileSpec;
+interface nsIURI;
+interface nsIObserver;
+interface nsIChannel;
+interface nsINetDataCache;
+interface nsINetDataCacheRecord;
+interface nsILoadGroup;
+interface nsIStreamListener;
+
+/**
+ * The nsICachedNetData interface represents a single entry in a database that
+ * caches data retrieved from the network. This interface is implemented by the
+ * cache manager on top of the low-level nsINetDataCacheRecord and
+ * nsINetDataCache interfaces that are implemented by the database.
+ *
+ * Each cache record may contain both content and metadata.  The content may
+ * be, for example, GIF image data or HTML, and it is accessed through
+ * nsIChannel's streaming API.  The opaque metadata, which may contain HTTP
+ * headers among other things, is stored as a byte array.  Each entry in the
+ * cache is indexed by two different keys: a record id number and a key created
+ * by combining the URI with a "secondary key", e.g. HTTP post data.
+ *
+ * @See nsINetDataCacheRecord
+ * @See nsINetDataCache
+ * @See nsINetDataDiskCache
+ * @See nsINetDataCacheManager
+ */
+[scriptable, uuid(6aeb2a40-6d43-11d3-90c8-000064657374)]
+interface nsICachedNetData : nsISupports
+{
+    /**
+     * String form of the URI provided as an argument to the call to
+     * nsINetDataCacheManager::GetCachedNetData() that created this record.
+     */
+    readonly attribute string uriSpec;
+    
+    /**
+     * Getter for the opaque secondary database key provided as an argument to
+     * the call to nsINetDataCacheManager::GetCachedNetData() that created this
+     * record.
+     */
+    void getSecondaryKey(out unsigned long length,
+                         [retval, size_is(length)] out string secondaryKey);
+
+    /**
+     * This flag may be set by a protocol handler to indicate that it supports
+     * partial fetching of data.  In that case, the cache manager is permitted
+     * to truncate the entry's content to accommodate incoming data for other
+     * cache entries rather than deleting it wholesale.
+     */
+    attribute boolean allowPartial;
+    
+    /**
+     * This flag indicates that the write stream supplying content data for the
+     * cache did not complete normally and, therefore, the content may be
+     * truncated.
+     */
+    readonly attribute boolean partialFlag;
+
+    /**
+     * This flag can be set and cleared by a protocol handler as a form of
+     * self-notification, so as to avoid race conditions in which a protocol
+     * handler issues two identical network requests to fill the same cache
+     * entry.  The cache manager itself largely ignores this flag.
+     */
+    attribute boolean updateInProgress;
+
+    /**
+     * inUse is set if any existing channels are associated with this cache
+     * entry or if the updateInProgess flag is set.  This can be used to
+     * prevent writing to a cache entry by a protocol handler if it's being
+     * read or written elsewhere.
+     */
+    readonly attribute boolean inUse;
+
+    /**
+     * Date/time that the document was last stored on the origin server, as
+     * supplied by the protocol handler.  This value is used as input to the
+     * cache replacement policy, i.e. it is not used for validation.  If the
+     * protocol can't supply a last-modified time, this attribute should remain
+     * unset.  When unset, the value of this attribute is zero.
+     *
+     * FIXME: Should use nsIDateTime interface, once it's created
+     * instead of PRTime, for improved scriptability ? 
+     */
+    attribute PRTime lastModifiedTime;
+
+    /**
+     * Supplied by the protocol handler, the expirationTime attribute specifies
+     * the time until which the document is guaranteed fresh, i.e. the document
+     * does not have to be validated with the server and, therefore, any data
+     * in cache is definitely usable.  The value of this attribute serves as a
+     * hint to the cache replacement policy.  Only one of either staleTime or
+     * expirationTime may be set for a single cache record.  When unset, the
+     * value of this attribute is zero. 
+     */
+    attribute PRTime expirationTime;
+
+    /**
+     * Date/time supplied by the protocol handler, at which point the content
+     * is *likely* to be stale, i.e. the data in the cache may be out-of-date
+     * with respect to the data on the server.  This heuristic date does not
+     * necessarily correspond to the HTTP Expires header, as it does not
+     * determine when cached network data must be validated with the origin
+     * server, but only serves as a hint to the cache replacement policy.  Only
+     * one of either staleTime or expirationTime may be set for a single cache
+     * record.  When unset, the value of this attribute is zero.
+     */
+    attribute PRTime staleTime;
+
+    /**
+     * Date/time of last access of the data in this cache record, as determined
+     * by the cache manager.
+     */
+    readonly attribute PRTime lastAccessTime;
+
+    /**
+     * Number of times this record has been accessed since it was first stored.
+     */
+    readonly attribute PRUint16 numberAccesses;
+
+    /**
+     * Accessor methods for opaque meta-data which can be read and updated
+     * independently of the content data.
+     *
+     * The aTag argument can be used to accommodate multiple clients of the
+     * cache API, each of which wants to store its own private meta-data into
+     * the cache.  For example, there could be a "headers" tag that the HTTP
+     * protocol handler uses to store http response headers and a "image size"
+     * tag used to store the image dimensions of a GIF file.  The aData
+     * argument refers to an opaque blob of arbitrary bytes.
+     *
+     * IMPORTANT: If aData does not contain byte-oriented data, i.e. it's not a
+     *            string, the contents of aData must be byte-swapped by the,
+     *            caller, so as to make the cache files endian-independent.
+     */
+    void getAnnotation(in string aTag, 
+                       out PRUint32 aLength, [size_is(aLength), retval] out string aData);
+    void setAnnotation(in string aTag,
+                       in  PRUint32 aLength, [size_is(aLength)] in string aData);
+
+    /**
+     * As a getter, return the number of content bytes stored in the cache,
+     * i.e. via the nsIChannel streaming APIs.  This may be less than the
+     * complete content length if a partial cache fill occurred.  The cached
+     * content can be truncated by setting the value of this attribute.  The
+     * value of the attribute represents a logical, not a physical, length.  If
+     * compression has been used, the content may consume less storage than
+     * indicated by this attribute.
+     *
+     * When this attribute is set to zero the associated cache disk file, if
+     * any, should be deleted.
+     */
+    attribute PRUint32 storedContentLength;
+
+    /** 
+     * Notify any observers associated with this cache entry of the deletion
+     * request.  If all observers drop their reference to the cache entry,
+     * proceed to delete the underlying cache database record and associated
+     * content storage.
+     */
+    void delete();
+
+    /**
+     * Flush any changes in this entry's data to the cache database.  This
+     * method will automatically be called when the last reference to the cache
+     * is dropped, but it can also be called explicitly for a synchronous
+     * effect.
+     */
+    void commit();
+
+    /**
+     * Parent container cache for this entry.
+     */
+    readonly attribute nsINetDataCache cache;
+
+    /**
+     * Create a channel for reading or writing a stream of content into the
+     * entry.  It is expected that many of the nsIChannel methods return
+     * NS_NOT_IMPLEMENTED, including:
+     *
+     *    + GetURI()
+     *    + GetContentType()
+     *    + GetContentLength()
+     *
+     * Though nsIChannel provides for both async and synchronous I/O APIs, both
+     * may not be implemented.  Only AsyncRead() and OpenOutputStream() is
+     * required.  The aProxyChannel argument allows another channel to be
+     * specified as the proffered argument to nsIStreamListener methods rather
+     * than the cache's own channel.
+     */
+    nsIChannel newChannel(in nsILoadGroup aLoadGroup,
+                          in nsIChannel aProxyChannel);
+
+    /**
+     * This method can be used by a caching protocol handler to store data in
+     * the cache by forking an asynchronous read stream so that it is
+     * simultaneously sent to a requester and written into the cache.  This
+     * method implicitly sets the updateInProgress flag, if it has not already
+     * been set.
+     */
+    nsIStreamListener interceptAsyncRead(in nsIStreamListener aOriginalListener,
+                                         in PRUint32 aStartOffset);
+};

mozilla/netwerk/cache/public/nsINetDataCache.idl

@@ -0,0 +1,143 @@
+/* -*- 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.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): 
+ */
+
+#include "nsISupports.idl"
+
+interface nsIURI;
+interface nsINetDataCacheRecord;
+interface nsISimpleEnumerator;
+interface nsIFileSpec;
+
+/**
+ * The nsINetDataCache defines the low-level API for a network-data
+ * cache, used to cache the responses to network retrieval commands.
+ * This interface, along with nsINetDataCacheRecord, is implemented by
+ * the memory cache, the file cache and, optionally, by some extension
+ * caches.  This interface is essentially a pseudo-private API for the
+ * cache manager.  Other clients should never use this interface.
+ *
+ * Each cache entry may contain both content, e.g. GIF image data, and
+ * associated metadata, e.g. HTTP headers.  Each entry is indexed by two
+ * different keys: a record id number and a key created by combining the URI
+ * with a "secondary key", e.g. HTTP post data.
+ *
+ * The nsINetDataCache interface is agnostic as to where the data is
+ * stored and whether the storage is volatile or persistent.  The
+ * memory cache, any disk caches and any extension caches must all
+ * implement this interface.
+ *
+ */
+[scriptable, uuid(ccfc58c0-6dde-11d3-90c8-000064657374)]
+interface nsINetDataCache : nsISupports
+{
+	/**
+	 * Human-readable description of the cache module, e.g. "Disk Cache"
+	 */
+	readonly attribute wstring description;
+  
+    /**
+     * Returns true if cached data is available for the given opaque key,
+     * even if only partial data is stored.
+     */
+    boolean contains([size_is(length)] in string key, in PRUint32 length);
+
+    /**
+     * Fetch the cache entry record for the given opaque key.  If one does not
+     * exist, create a new, empty record.
+     */
+    nsINetDataCacheRecord getCachedNetData([size_is(length)] in string key,
+                                           in PRUint32 length);
+
+    /**
+     * Fetch the cache entry record for the given URI using the record ID as a key.
+     */
+    nsINetDataCacheRecord getCachedNetDataByID(in PRInt32 RecordID);
+
+	/**
+	 * False indicates that this cache is entirely bypassed.
+	 */
+    attribute boolean enabled;
+
+    /**
+     * Constants for flags attribute, below
+     */
+
+    // Used for extension caches, e.g. a CD-ROM cache
+    const long READ_ONLY          = 1 << 0;
+
+    // One of these bits must be set
+    const long MEMORY_CACHE       = 1 << 1;
+    const long FLAT_FILE_CACHE    = 1 << 2;
+    const long FILE_PER_URL_CACHE = 1 << 3;
+
+	/**
+	 * See constants defined above.
+	 */
+	readonly attribute PRUint32 flags;
+
+    /**
+     * Total number of URI entries stored in the cache.
+     */
+    readonly attribute PRUint32 numEntries;
+
+    /**
+     * Maximum number of URI entries that may be stored in the cache.
+     */
+    readonly attribute PRUint32 maxEntries;
+
+    /**
+     * Enumerate the URI entries stored in the cache.
+     */
+    nsISimpleEnumerator newCacheEntryIterator();
+
+	/**
+	 * Contains a reference to the next cache in search order.  For the memory
+	 * cache, this attribute always references the disk cache.  For the disk
+	 * cache, it contains a reference to the first extension cache.
+	 */
+    attribute nsINetDataCache nextCache;
+
+    /**
+     * An estimate of the amount of storage occupied by the cache, in kB.
+     * Actual use may be slightly higher than reported due to cache overhead
+     * and heap fragmentation (in the memory cache) or block quantization (in
+     * the disk cache).
+	 */
+    readonly attribute PRUint32 storageInUse;
+
+    /**
+     * Remove all entries from a writable cache.  This could be used, for
+     * example, after a guest ends a browser session.  This is equivalent to
+     * setting the cache's Capacity to zero, except that all cache entries,
+     * even those in active use, will be deleted.  Also, any global cache
+     * database files will be deleted.
+	 */
+    void removeAll();
+};
+
+%{ C++
+// ProgID prefix for Components that implement this interface
+#define NS_NETWORK_CACHE_PROGID "component://netscape/network/cache"
+#define NS_NETWORK_MEMORY_CACHE_PROGID NS_NETWORK_CACHE_PROGID "?name=memory-cache"
+#define NS_NETWORK_FLAT_CACHE_PROGID   NS_NETWORK_CACHE_PROGID "?name=flat-cache"
+#define NS_NETWORK_FILE_CACHE_PROGID   NS_NETWORK_CACHE_PROGID "?name=file-cache"
+%}

mozilla/netwerk/cache/public/nsINetDataCacheManager.idl

@@ -0,0 +1,163 @@
+/* -*- 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.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): 
+ */
+
+#include "nsISupports.idl"
+
+interface nsISimpleEnumerator;
+interface nsICachedNetData;
+interface nsINetDataCache;
+interface nsINetDataDiskCache;
+interface nsIURI;
+interface nsIFileSpec;
+
+/**
+ * The network-response cache manager is partly responsible for the caching of
+ * content and associated metadata that has been retrieved via the network.
+ * (The remaining responsibility for caching lies with individual network
+ * protocol handlers.)
+ *
+ * The cache manager supervises the actions of individual cache components,
+ * such as the memory cache, the disk cache and any extension caches, e.g. a
+ * read-only CD-ROM cache.
+ *
+ * @See nsINetDataCache
+ * @See nsICachedNetData
+ */
+[scriptable, uuid(71c8ab00-6d5c-11d3-90c8-000064657374)]
+interface nsINetDataCacheManager : nsISupports
+{
+    /**
+     * Flag for the GetCachedNetData() method: If set, the memory cache is
+     * neither searched nor will any data be stored into it.  This might be
+     * appropriate, for example, with images, because they have their own
+     * cache for storing *decoded* images.
+     */
+    const unsigned long BYPASS_MEMORY_CACHE       = 1 << 0;
+
+    /**
+     * Flag for the GetCachedNetData() method: If set, the disk cache
+     * is neither searched nor will any be data stored into it.
+     * However, read-only extension caches may be searched.  This
+     * might be used to avoid leaving persistent records of secure
+     * data.
+     */
+    const unsigned long BYPASS_PERSISTENT_CACHE   = 1 << 1;
+
+    /**
+     * Flag for the GetCachedNetData() method: If set, any stream
+     * content is stored in the cache as a single disk file.  Content
+     * will not be cached in the memory cache nor is it cached in a
+     * flat-file cache database.  This is used to implement the jar
+     * protocol handler and to provide the stream-as-file semantics
+     * required by the classic bowser plugin API.
+     */
+    const unsigned long CACHE_AS_FILE             = 1 << 2;
+
+    /**
+     * Fetch the cache entry record for the given URI.  If one does not exist,
+     * create a new, empty record.  The normal search order for caches is:
+     *   + Memory cache
+     *   + Disk cache
+     *   + File cache (stream-as-file cache)
+     *   + All extension caches
+     *
+     * When writing, data is typically stored in both the memory cache and the
+     * disk cache.  Both the search order and this write policy can be modified by
+     * setting one or more of the flag argument bits, as defined above.
+     *
+     * The optionally-NULL secondaryKey argument can be used, e.g. for form
+     * post data or for HTTP headers in the case of HTTP.
+     */
+    nsICachedNetData getCachedNetData(in string uri,
+                                      [size_is(secondaryKeyLength)] in string secondaryKey,
+                                      in PRUint32 secondaryKeyLength,
+                                      in PRUint32 flags);
+
+    /**
+     * Returns true if cached content is available for the given URI, even if
+     * only partial data is stored.  The flags argument behaves the same as for
+     * the GetCachedNetData() method, above.
+     */
+    boolean contains(in string uri,
+                     [size_is(secondaryKeyLength)] in string secondaryKey,
+                     in PRUint32 secondaryKeyLength,
+                     in PRUint32 flags);
+
+    /**
+     * Total number of unexpired URI entries stored in all caches.  This number
+     * does not take into account duplicate URIs, e.g. because the memory cache
+     * and the disk cache might each contain an entry for the same URI.
+     */
+    readonly attribute PRUint32 numEntries;
+
+    /**
+     * Enumerate the unexpired URI entries stored in all caches.  Some URIs may
+     * be enumerated more than once, e.g.  because the the memory cache and the
+     * disk cache might each contain an entry for the same URI.
+     */
+    nsISimpleEnumerator newCacheEntryIterator();
+
+    /*
+     * Enumerate all the loaded nsINetDataCache-implementing cache modules.
+     * The first module enumerated will be the memory cache, the second will be
+     * the disk cache, then the file cache, followed by all the extension
+     * caches, in search order. 
+     */
+    nsISimpleEnumerator newCacheModuleIterator();
+
+    /**
+     * Remove all entries from all writable caches.  This could be used, for
+     * example, after a guest ends a browser session.  This is equivalent to
+     * setting the DiskCacheCapacity to zero, except that all cache entries,
+     * even those in active use, will be deleted.  Also, any global cache
+     * database files will be deleted.
+     */
+    void RemoveAll();
+
+    /**
+     * The disk cache is made up of the file cache (for stream-as-file
+     * requests) and a (possibly independent) persistent cache that handles all
+     * other cache requests.  This attribute sets/gets the combined capacity of
+     * these caches, measured in KBytes.  Setting the capacity lower than the
+     * current amount of space currently in use may cause cache entries to be
+     * evicted from the cache to accomodate the requested capacity.
+     */
+    attribute PRUint32 diskCacheCapacity;
+
+    /**
+     * This attribute sets/gets the capacity of the memory cache, measured in
+     * KBytes.  Setting the capacity lower than the current amount of space
+     * currently in use may cause cache entries to be evicted from the cache to
+     * accomodate the requested capacity.
+     */
+    attribute PRUint32 memCacheCapacity;
+
+	/**
+	 * This attribute must be set before attempting to store into the disk cache.
+	 */
+    attribute nsIFileSpec diskCacheFolder;
+};
+
+%{ C++
+// ProgID prefix for Components that implement this interface
+#define NS_NETWORK_CACHE_MANAGER_PROGID NS_NETWORK_CACHE_PROGID "?name=manager"
+%}

mozilla/netwerk/cache/public/nsINetDataCacheRecord.idl

@@ -0,0 +1,125 @@
+/* -*- 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.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): 
+ */
+
+#include "nsISupports.idl"
+#include "nsrootidl.idl"
+
+interface nsIFileSpec;
+interface nsIChannel;
+interface nsINetDataCache;
+
+/**
+ * The nsINetDataCacheRecord represents a single entry in a database that
+ * caches data retrieved from the network. On top of this low-level interface
+ * to the raw record data, the cache manager implements a higher-level record
+ * interface, nsICachedNetData.  Each instance of nsINetDataCacheRecord is
+ * (internally) associated with a parent database, an instance of the
+ * nsINetDataCache interface.  This interface is essentially a pseudo-private
+ * API for the cache manager.  Other clients should never use this interface.
+ *
+ * Each cache record may contain both content and metadata.  The content may
+ * be, for example, GIF image data or HTML, and it is accessed through
+ * nsIChannel's streaming API.  The opaque metadata, which may contain HTTP
+ * headers among other things, is accessed as a contiguous byte array.  Each
+ * entry in the cache is indexed by two different keys: a unique record id
+ * number, generated by the cache, and an opaque string.  The latter contains
+ * the URI and other secondary key information, e.g. HTTP form post key/value
+ * pairs.
+ *
+ * The nsINetDataCacheRecord interface is agnostic as to where the data is
+ * stored and whether the storage is volatile or persistent.  The memory cache,
+ * the disk cache, a flat-file cache and any read-only extension caches must
+ * all implement this interface.
+ *
+ * @See nsICachedNetData
+ * @See nsINetDataCache
+ * @See nsINetDataDiskCache
+ * @See nsINetDataCacheManager
+ */
+
+interface nsILoadGroup;
+
+[scriptable, uuid(fdcdd6a0-7461-11d3-90ca-0040056a906e)]
+interface nsINetDataCacheRecord : nsISupports
+{
+    /**
+     * As far as the nsINetDataCacheRecord implementation is concerned, the
+     * cache entry database key is an opaque blob, but it's intended to contain
+     * both the URI and any secondary keys, such as HTTP post data.
+     */
+    void getKey(out unsigned long length, [size_is(length), retval] out string key);
+
+    /**
+     * A persistent record number assigned by the cache which must be unique
+     * among all entries stored within the same cache.  The record ID serves as
+     * an alternate key to the cache record.  Providing that they satisfy the
+     * afforementioned uniqueness requirement, record IDs can be assigned any
+     * value by the database except that they may never be zero.
+     */
+    readonly attribute PRInt32 recordID;
+
+    /**
+     * Opaque data which can be updated for each cache entry independently of
+     * the content data.  This data is a combination of protocol-independent
+     * data provided by the cache manager and protocol-specific meta-data,
+     * e.g. HTTP headers.
+     */
+    void getMetaData(out PRUint32 length, [size_is(length), retval] out string metaData);
+    void setMetaData(in  PRUint32 length, [size_is(length)] in string data);
+
+    /**
+     * Number of content bytes stored in the cache, i.e. via the nsIChannel
+     * streaming APIs.  This may be less than the complete content length if a
+     * partial cache fill occurred.  Additionally, the cached content can be
+     * truncated by reducing the value of this attribute.  When this attribute
+     * is set to zero the associated cache disk file, if any, should be
+     * deleted.
+     */
+    attribute PRUint32 storedContentLength;
+
+    /** 
+     * Delete this cache entry and its associated content.
+     */
+    void delete();
+
+    /**
+     * Create a channel for reading or writing a stream of content into the
+     * entry.  However, many of the nsIChannel methods may return
+     * NS_NOT_IMPLEMENTED, including:
+     *
+     *    + GetURI()
+     *    + GetContentType()
+     *    + GetContentLength()
+     */
+    nsIChannel newChannel(in nsILoadGroup loadGroup);
+
+    /**
+     * If a cache is implemented such that it stores each URI's content in an
+     * individual disk file, this method will identify the file corresponding
+     * to this record.  This may be used to implement the "stream-as-file"
+     * semantics required by some plugins and by the 'jar:' protocol handler.
+     * However, not all cache implementations are *required* to store the data
+     * from each URI in an individual file, so it is acceptable for an
+     * implementation of this method to signal NS_NOT_IMPLEMENTED.
+     */
+    readonly attribute nsIFileSpec filename;
+};

mozilla/netwerk/cache/public/nsINetDataDiskCache.idl

@@ -0,0 +1,42 @@
+/* -*- 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.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): 
+ */
+
+#include "nsINetDataCache.idl"
+
+interface nsIFileSpec;
+
+/**
+/**
+ * A network-data disk cache is used to persistently cache the responses to
+ * network retrieval commands.  Each cache entry may contain both content,
+ * e.g. GIF image data, and associated metadata, e.g. HTTP headers.
+ */
+[scriptable, uuid(6408e390-6f13-11d3-90c8-000064657374)]
+interface nsINetDataDiskCache : nsINetDataCache
+{
+	/**
+	 * This attribute must be set before calling any other methods of this
+	 * interface.
+	 */
+    attribute nsIFileSpec diskCacheFolder;
+};
+

mozilla/netwerk/cache/public/nsIStreamAsFile.idl

@@ -0,0 +1,106 @@
+/* -*- 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.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 Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *   Scott Furman, fur@netscape.com
+ */
+#include "nsrootidl.idl"
+#include "nsISupports.idl"
+
+interface nsIFileSpec;
+interface nsIStreamAsFileObserver;
+
+/**
+ * In addition to enhancing effective network response time via caching, the
+ * cache manager serves a second purpose by providing the stream-as-file
+ * service required by traditional browser plugins and the jar: protocol
+ * handler.  The interface below provides a means for a client to determine the
+ * filename associated with a stream and to detect modification/deletion of
+ * that file.
+ */
+[scriptable, uuid(0eedbbf0-92d9-11d3-90d3-0040056a906e)]
+interface nsIStreamAsFile : nsISupports
+{
+    /**
+     * Filename containing stream-as-file
+     */
+    readonly attribute nsIFileSpec fileSpec;
+
+    /**
+     * Add an observer for this cache record.  When the cache wants to delete
+     * or truncate a record, so as to make space for another cache entry's
+     * content data, it will call <code>aObserver</code>'s Observe() method,
+     * passing the nsIStreamAsFile instance as the <code>aSubject</code>
+     * argument and an appropriate message.  If the observer does not wish to
+     * inhibit deletion/truncation, it should Release() any references it has to the
+     * cache record.
+     *
+     * @See nsIStreamAsFileObserver
+     */
+    void addObserver(in nsIStreamAsFileObserver aObserver);
+
+    /**
+     * Delete an observer that was added by the AddObserver() method.
+     */
+    void removeObserver(in nsIStreamAsFileObserver aObserver);
+};
+
+/**
+ * This interface can be implemented by a client to receive notifications of
+ * either modification or deletion of a file created by the cache manager using
+ * the stream-as-file semantics.
+ */
+[scriptable, uuid(a26e27c0-92da-11d3-90d3-0040056a906e)]
+interface nsIStreamAsFileObserver : nsISupports
+{
+    /**
+     * Flag bits for argument to Observe() method.
+     */
+    const long NOTIFY_AVAILABLE    = 1 << 0; // Stream-as-file now available for reading
+    const long NOTIFY_ERROR        = 1 << 1; // Error while loading stream / creating file
+    const long REQUEST_DELETION    = 1 << 2; // Cache manager wishes to delete/truncate file
+    const long INVALIDATE          = 1 << 3; // File is out-of-date
+
+    // Convenience value
+    const long MAKE_UNAVAILABLE    = REQUEST_DELETION | INVALIDATE;
+    
+    /**
+     * Receive either a notification or a request concerning a file that has
+     * been opened using stream-as-file.  The aMessage and aError arguments
+     * have varying values depending on the nature of the notification.
+     * aMessage is set to NOTIFY_AVAILABLE when a complete stream has been read
+     * and stored on disk in a file.  At that point, and no sooner, may the
+     * filename attribute of the associated nsIStreamAsFile be accessed via the
+     * associated nsIStreamAsFile interface.  If the aMessage argument is
+     * NOTIFY_ERROR, the aError argument contains the relevant error code.  If
+     * the aMessage argument is either REQUEST_DELETION or REQUEST_TRUNCATION,
+     * the callee should immediately Release() all references to the
+     * nsIStreamAsFile (and any references to its associated nsICachedNetData
+     * instances), unless it wishes to inhibit the requested file modification.
+     * If the aMessage argument is INVALIDATE, the cache manager is replacing
+     * the file with a more recent version.  If a client wants to continue
+     * using the (now out-of-date) file, it must delete it when it has finished,
+     * as the cache manager will effectively relinquished ownership of the
+     * file.
+     */
+    void ObserveStreamAsFile(in nsIStreamAsFile aStreamAsFile,
+			     in PRUint32 aMessage,
+			     in nsresult aError);
+};

mozilla/netwerk/makefile.win

@@ -1,3 +1,4 @@
+#!gmake
 #
 # The contents of this file are subject to the Netscape Public
 # License Version 1.1 (the "License"); you may not use this file
@@ -17,15 +18,22 @@
 # Rights Reserved.
 #
 # Contributor(s): 
-#
 
-DEPTH		= ..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
+DEPTH = ..
 
-include $(DEPTH)/config/autoconf.mk
+MODULE = necko
 
-DIRS		= psm
+DIRS=            \
+	base     \
+	dns      \
+	build    \
+	protocol \
+	socket   \
+	util     \
+	mime     \
+	streamconv \
+	cache    \
+	test     \
+	$(NULL)
 
-include $(topsrcdir)/config/rules.mk
+include <$(DEPTH)\config\rules.mak>

mozilla/netwerk/protocol/http/public/nsIHTTPHeader.idl

@@ -0,0 +1,32 @@
+/* -*- Mode: IDL; 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.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): 
+ */
+
+#include "nsISupports.idl"
+
+interface nsIAtom;
+                  
+[scriptable, uuid(a3ec67f0-465a-11d3-9a89-0080c7cb1080)]
+interface nsIHTTPHeader : nsISupports
+{
+    nsIAtom GetField();
+    string GetValue();
+};

mozilla/netwerk/test/TestCacheMgr.cpp

@@ -0,0 +1,603 @@
+/* -*- Mode: C++; tab-width: 2; 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 "nsIStreamListener.h"
+#include "nsIStreamObserver.h"
+#include "nsIServiceManager.h"
+#include "nsIInputStream.h"
+#include "nsIOutputStream.h"
+#include "nsIEventQueue.h"
+#include "nsIEventQueueService.h"
+#include "nsIChannel.h"
+#include "nsCOMPtr.h"
+
+#include "nsINetDataCache.h"
+#include "nsINetDataCacheManager.h"
+#include "nsICachedNetData.h"
+
+
+// Number of test entries to be placed in the cache
+// FIXME - temporary
+#define NUM_CACHE_ENTRIES  25
+
+// Cache content stream length will have random length between zero and
+// MAX_CONTENT_LENGTH bytes
+#define MAX_CONTENT_LENGTH 20000
+
+// Limits, converted to KB
+#define DISK_CACHE_CAPACITY  ((MAX_CONTENT_LENGTH * 4) >> 10)
+#define MEM_CACHE_CAPACITY   ((MAX_CONTENT_LENGTH * 3) >> 10)
+
+// Length of random-data cache entry URI key
+#define CACHE_KEY_LENGTH 13
+
+// Length of random-data cache entry secondary key
+#define CACHE_SECONDARY_KEY_LENGTH 10
+
+// Length of random-data cache entry meta-data
+#define CACHE_PROTOCOL_PRIVATE_LENGTH 10
+
+// Mapping from test case number to RecordID
+static PRInt32 recordID[NUM_CACHE_ENTRIES];
+
+static PRInt32
+mapRecordIdToTestNum(PRInt32 aRecordID)
+{
+    int i;
+    for (i = 0; i < NUM_CACHE_ENTRIES; i++) {
+        if (recordID[i] == aRecordID)
+            return i;
+    }
+    return -1;
+}
+
+// A supply of stream data to either store or compare with
+class nsITestDataStream {
+public:
+    virtual ~nsITestDataStream() {};
+    virtual PRUint32 Next() = 0;
+    virtual void Read(char* aBuf, PRUint32 aCount) = 0;
+    virtual void ReadString(char* aBuf, PRUint32 aCount) = 0;
+
+    virtual PRBool Match(char* aBuf, PRUint32 aCount) = 0;
+    virtual PRBool MatchString(char* aBuf, PRUint32 aCount) = 0;
+    virtual void Skip(PRUint32 aCount) = 0;
+    virtual void SkipString(PRUint32 aCount) = 0;
+};
+
+// A reproducible stream of random data.
+class RandomStream : public nsITestDataStream {
+public:
+    RandomStream(PRUint32 aSeed) {
+        mStartSeed = mState = aSeed;
+    }
+    
+    PRUint32 GetStartSeed() {
+        return mStartSeed;
+    }
+    
+    PRUint32 Next() {
+        mState = 1103515245 * mState + 12345 ^ (mState >> 16);
+        return mState;
+    }
+
+    PRUint8 NextChar() {
+        PRUint8 c;
+        do {
+            c = Next();
+        } while (!isalnum(c));
+        return c;
+    }
+
+    void Read(char* aBuf, PRUint32 aCount) {
+        PRUint32 i;
+        for (i = 0; i < aCount; i++) {
+            *aBuf++ = Next();
+        }
+    }
+
+    // Same as Read(), but using only printable chars and
+    //   with a terminating NUL
+    void ReadString(char* aBuf, PRUint32 aCount) {
+        PRUint32 i;
+        for (i = 0; i < aCount; i++) {
+            *aBuf++ = NextChar();
+        }
+        *aBuf = 0;
+    }
+
+    PRBool
+    Match(char* aBuf, PRUint32 aCount) {
+        PRUint32 i;
+        for (i = 0; i < aCount; i++) {
+            if (*aBuf++ != (char)(Next() & 0xff))
+                return PR_FALSE;
+        }
+        return PR_TRUE;
+    }
+
+    PRBool
+    MatchString(char* aBuf, PRUint32 aCount) {
+        PRUint32 i;
+        for (i = 0; i < aCount; i++) {
+            if (*aBuf++ != (char)(NextChar() & 0xff))
+                return PR_FALSE;
+        }
+        
+        // Check for terminating NUL character
+        if (*aBuf)
+            return PR_FALSE;
+        return PR_TRUE;
+    }
+
+    void
+    Skip(PRUint32 aCount) {
+        while (aCount--)
+            Next();
+    }
+
+    void
+    SkipString(PRUint32 aCount) {
+        while (aCount--)
+            NextChar();
+    }
+
+protected:
+    
+    PRUint32 mState;
+    PRUint32 mStartSeed;
+};
+
+static int gNumReaders = 0;
+static PRUint32 gTotalBytesRead = 0;
+static PRUint32 gTotalBytesWritten = 0;
+static PRUint32 gTotalDuration = 0;
+
+class nsReader : public nsIStreamListener {
+public:
+    NS_DECL_ISUPPORTS
+
+    nsReader()
+        : mStartTime(0), mBytesRead(0)
+    {
+        NS_INIT_REFCNT();
+        gNumReaders++;
+    }
+
+    virtual ~nsReader() {
+        delete mTestDataStream;
+        gNumReaders--;
+    }
+
+    nsresult 
+    Init(nsITestDataStream* aRandomStream, PRUint32 aExpectedStreamLength) {
+        mTestDataStream = aRandomStream;
+        mExpectedStreamLength = aExpectedStreamLength;
+        mRefCnt = 1;
+        return NS_OK;
+    }
+
+    NS_IMETHOD OnStartRequest(nsIChannel* channel,
+                              nsISupports* context) {
+        mStartTime = PR_IntervalNow();
+        return NS_OK;
+    }
+
+    NS_IMETHOD OnDataAvailable(nsIChannel* channel, 
+                               nsISupports* context,
+                               nsIInputStream *aIStream, 
+                               PRUint32 aSourceOffset,
+                               PRUint32 aLength) {
+        char buf[1025];
+        while (aLength > 0) {
+            PRUint32 amt;
+            PRBool match;
+            aIStream->Read(buf, sizeof buf, &amt);
+            if (amt == 0) break;
+            aLength -= amt;
+            mBytesRead += amt;
+            match = mTestDataStream->Match(buf, amt);
+            NS_ASSERTION(match, "Stored data was corrupted on read");
+        }
+        return NS_OK;
+    }
+
+    NS_IMETHOD OnStopRequest(nsIChannel* channel, 
+                             nsISupports* context,
+                             nsresult aStatus,
+                             const PRUnichar* aMsg) {
+        PRIntervalTime endTime;
+        PRIntervalTime duration;
+        
+        endTime = PR_IntervalNow();
+        duration = (endTime - mStartTime);
+
+        if (NS_FAILED(aStatus)) printf("channel failed.\n");
+        //        printf("read %d bytes\n", mBytesRead);
+
+        //FIXME        NS_ASSERTION(mBytesRead == mExpectedStreamLength,
+        // "Stream in cache is wrong length");
+
+        gTotalBytesRead += mBytesRead;
+        gTotalDuration += duration;
+
+        return NS_OK;
+    }
+
+protected:
+    PRIntervalTime       mStartTime;
+    PRUint32             mBytesRead;
+    nsITestDataStream*   mTestDataStream;
+    PRUint32             mExpectedStreamLength;
+};
+
+NS_IMPL_ISUPPORTS2(nsReader, nsIStreamListener, nsIStreamObserver)
+
+static nsIEventQueue* eventQueue;
+
+static NS_DEFINE_CID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID);
+
+nsresult
+InitQueue() {
+    nsresult rv;
+
+    NS_WITH_SERVICE(nsIEventQueueService, eventQService, kEventQueueServiceCID, &rv);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get event queue service");
+
+    rv = eventQService->CreateThreadEventQueue();
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't create event queue");
+  
+    rv = eventQService->GetThreadEventQueue(PR_CurrentThread(), &eventQueue);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get event queue for main thread");
+
+    return NS_OK;
+}
+
+// Process events until all streams are OnStopRequest'ed
+nsresult
+WaitForEvents() {
+    while (gNumReaders) {
+        eventQueue->ProcessPendingEvents();
+    }
+    return NS_OK;
+}
+
+// Read data for a single cache record and compare against testDataStream
+nsresult
+TestReadStream(nsICachedNetData *cacheEntry, nsITestDataStream *testDataStream,
+               PRUint32 expectedStreamLength)
+{
+    nsCOMPtr<nsIChannel> channel;
+    nsresult rv;
+    PRUint32 actualContentLength;
+
+    rv = cacheEntry->NewChannel(0, 0, getter_AddRefs(channel));
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+    rv = cacheEntry->GetStoredContentLength(&actualContentLength);
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+    // FIXME    NS_ASSERTION(actualContentLength == expectedStreamLength,
+    //                 "nsICachedNetData::GetContentLength() busted ?");
+    
+    nsReader *reader = new nsReader;
+    reader->AddRef();
+    rv = reader->Init(testDataStream, expectedStreamLength);
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+    
+    rv = channel->AsyncRead(0, -1, 0, reader);
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+    reader->Release();
+
+    return NS_OK;
+}
+
+// Convert PRTime to unix-style time_t, i.e. seconds since the epoch
+static PRUint32
+convertPRTimeToSeconds(PRTime aTime64)
+{
+    double fpTime;
+    LL_L2D(fpTime, aTime64);
+    return (PRUint32)(fpTime * 1e-6 + 0.5);
+}
+
+// Convert unix-style time_t, i.e. seconds since the epoch, to PRTime
+static PRTime
+convertSecondsToPRTime(PRUint32 aSeconds)
+{
+    PRInt64 t64;
+    LL_L2I(t64, aSeconds);
+    LL_MUL(t64, t64, 1000000);
+    return t64;
+}
+
+// Read the test data that was written in FillCache(), checking for
+// corruption, truncation.
+nsresult
+TestRead(nsINetDataCacheManager *aCache, PRUint32 aFlags)
+{
+    nsresult rv;
+    PRBool inCache;
+    nsCOMPtr<nsICachedNetData> cacheEntry;
+    RandomStream *randomStream;
+    char uriCacheKey[CACHE_KEY_LENGTH];
+    char secondaryCacheKey[CACHE_SECONDARY_KEY_LENGTH];
+    char *storedUriKey;
+    PRUint32 testNum;
+
+    gTotalBytesRead = 0;
+    gTotalDuration = 0;
+    for (testNum = 0; testNum < NUM_CACHE_ENTRIES; testNum++) {
+        randomStream = new RandomStream(testNum);
+        randomStream->ReadString(uriCacheKey, sizeof uriCacheKey - 1);
+        randomStream->Read(secondaryCacheKey, sizeof secondaryCacheKey);
+
+        // Ensure that entry is in the cache
+        rv = aCache->Contains(uriCacheKey,
+                              secondaryCacheKey, sizeof secondaryCacheKey,
+                              aFlags, &inCache);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        NS_ASSERTION(inCache, "nsINetDataCacheManager::Contains error");
+        
+        rv = aCache->GetCachedNetData(uriCacheKey,
+                                      secondaryCacheKey, sizeof secondaryCacheKey,
+                                      aFlags,
+                                      getter_AddRefs(cacheEntry));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+        // Test GetUriSpec() method
+        rv = cacheEntry->GetUriSpec(&storedUriKey);
+        NS_ASSERTION(NS_SUCCEEDED(rv) &&
+                     !memcmp(storedUriKey, &uriCacheKey[0], sizeof uriCacheKey),
+                     "nsICachedNetData::GetKey failed");
+        nsAllocator::Free(storedUriKey);
+
+        // Test GetSecondaryKey() method
+        PRUint32 storedSecondaryKeyLength;
+        char* storedSecondaryKey;
+        rv = cacheEntry->GetSecondaryKey(&storedSecondaryKeyLength, &storedSecondaryKey);
+        NS_ASSERTION(NS_SUCCEEDED(rv) &&
+                     !memcmp(storedSecondaryKey, &secondaryCacheKey[0],
+                             sizeof secondaryCacheKey),
+                     "nsICachedNetData::GetSecondaryKey failed");
+
+        // Compare against stored protocol data
+        char *storedProtocolData;
+        PRUint32 storedProtocolDataLength;
+        rv = cacheEntry->GetAnnotation("test data", &storedProtocolDataLength, &storedProtocolData);
+        NS_ASSERTION(NS_SUCCEEDED(rv) &&
+                     storedProtocolDataLength == CACHE_PROTOCOL_PRIVATE_LENGTH,
+                     "nsICachedNetData::GetAnnotation() failed");
+        randomStream->Match(storedProtocolData, storedProtocolDataLength);
+
+        // Test GetAllowPartial()
+        PRBool allowPartial;
+        rv = cacheEntry->GetAllowPartial(&allowPartial);
+        NS_ASSERTION(NS_SUCCEEDED(rv) &&
+                     (allowPartial == (PRBool)(randomStream->Next() & 1)),
+                     "nsICachedNetData::GetAllowPartial() failed");
+
+        // Test GetExpirationTime()
+        PRTime expirationTime;
+        PRTime expectedExpirationTime = convertSecondsToPRTime(randomStream->Next() & 0xffffff);
+        rv = cacheEntry->GetExpirationTime(&expirationTime);
+
+        NS_ASSERTION(NS_SUCCEEDED(rv) && LL_EQ(expirationTime, expectedExpirationTime),
+                     "nsICachedNetData::GetExpirationTime() failed");
+
+        PRUint32 expectedStreamLength = randomStream->Next() % MAX_CONTENT_LENGTH;
+
+        TestReadStream(cacheEntry, randomStream, expectedStreamLength);
+    }
+
+    WaitForEvents();
+
+    // Compute rate in MB/s
+    double rate = gTotalBytesRead / PR_IntervalToMilliseconds(gTotalDuration);
+    rate *= NUM_CACHE_ENTRIES;
+    rate *= 1000;
+    rate /= (1024 * 1024);
+    printf("Read  %7d bytes at a rate of %5.1f MB per second \n",
+           gTotalBytesRead, rate);
+
+    return NS_OK;
+}
+
+// Create entries in the network data cache, using random data for the
+// key, the meta-data and the stored content data.
+nsresult
+FillCache(nsINetDataCacheManager *aCache, PRUint32 aFlags, PRUint32 aCacheCapacity)
+{
+    nsresult rv;
+    PRBool inCache;
+    nsCOMPtr<nsICachedNetData> cacheEntry;
+    nsCOMPtr<nsIChannel> channel;
+    nsCOMPtr<nsIOutputStream> outStream;
+    nsCOMPtr<nsINetDataCache> containingCache;
+    char buf[1000];
+    PRUint32 protocolDataLength;
+    char cacheKey[CACHE_KEY_LENGTH];
+    char secondaryCacheKey[CACHE_SECONDARY_KEY_LENGTH];
+    char protocolData[CACHE_PROTOCOL_PRIVATE_LENGTH];
+    PRUint32 testNum;
+    RandomStream *randomStream;
+
+    gTotalBytesWritten = 0;
+    PRIntervalTime startTime = PR_IntervalNow();
+    
+    for (testNum = 0; testNum < NUM_CACHE_ENTRIES; testNum++) {
+        randomStream = new RandomStream(testNum);
+        randomStream->ReadString(cacheKey, sizeof cacheKey - 1);
+        randomStream->Read(secondaryCacheKey, sizeof secondaryCacheKey);
+
+        // No entry should be in cache until we add it
+        rv = aCache->Contains(cacheKey,
+                              secondaryCacheKey, sizeof secondaryCacheKey,
+                              aFlags, &inCache);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        NS_ASSERTION(!inCache, "nsINetDataCacheManager::Contains error");
+        
+        rv = aCache->GetCachedNetData(cacheKey,
+                                      secondaryCacheKey, sizeof secondaryCacheKey,
+                                      aFlags,
+                                      getter_AddRefs(cacheEntry));
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't access cacheEntry via cache key");
+
+        // Test nsINetDataCacheManager::GetNumEntries()
+        PRUint32 numEntries = (PRUint32)-1;
+        rv = aCache->GetNumEntries(&numEntries);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get number of cache entries");
+        NS_ASSERTION(numEntries == testNum + 1, "GetNumEntries failure");
+
+        // Record meta-data should be initially empty
+        char *protocolDatap;
+        rv = cacheEntry->GetAnnotation("test data", &protocolDataLength, &protocolDatap);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        if ((protocolDataLength != 0) || (protocolDatap != 0))
+            return NS_ERROR_FAILURE;
+
+        // Store random data as meta-data
+        randomStream->Read(protocolData, sizeof protocolData);
+        cacheEntry->SetAnnotation("test data", sizeof protocolData, protocolData);
+
+        // Store random data as allow-partial flag
+        PRBool allowPartial = randomStream->Next() & 1;
+        rv = cacheEntry->SetAllowPartial(allowPartial);
+        NS_ASSERTION(NS_SUCCEEDED(rv),
+                     "nsICachedNetData::SetAllowPartial() failed");
+
+        // Store random data as expiration time
+        PRTime expirationTime = convertSecondsToPRTime(randomStream->Next() & 0xffffff);
+        rv = cacheEntry->SetExpirationTime(expirationTime);
+        NS_ASSERTION(NS_SUCCEEDED(rv),
+                     "nsICachedNetData::SetExpirationTime() failed");
+
+        // Cache manager complains if expiration set without setting last-modified time
+        rv = cacheEntry->SetLastModifiedTime(expirationTime);
+
+        rv = cacheEntry->NewChannel(0, 0, getter_AddRefs(channel));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+        rv = cacheEntry->GetCache(getter_AddRefs(containingCache));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+        rv = channel->OpenOutputStream(0, getter_AddRefs(outStream));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        
+        int streamLength = randomStream->Next() % MAX_CONTENT_LENGTH;
+        int remaining = streamLength;
+        while (remaining) {
+            PRUint32 numWritten;
+            int amount = PR_MIN(sizeof buf, remaining);
+            randomStream->Read(buf, amount);
+
+            rv = outStream->Write(buf, amount, &numWritten);
+            NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+            NS_ASSERTION(numWritten == (PRUint32)amount, "Write() bug?");
+            
+            remaining -= amount;
+
+            PRUint32 storageInUse;
+            rv = containingCache->GetStorageInUse(&storageInUse);
+            NS_ASSERTION(NS_SUCCEEDED(rv) && (storageInUse <= aCacheCapacity),
+                         "Cache manager failed to limit cache growth");
+        }
+        outStream->Close();
+        gTotalBytesWritten += streamLength;
+
+        // *Now* there should be an entry in the cache
+        rv = aCache->Contains(cacheKey,
+                              secondaryCacheKey, sizeof secondaryCacheKey,
+                              aFlags, &inCache);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        NS_ASSERTION(inCache, "nsINetDataCacheManager::Contains error");
+
+        delete randomStream;
+    }
+
+    PRIntervalTime endTime = PR_IntervalNow();
+
+    // Compute rate in MB/s
+    double rate = gTotalBytesWritten / PR_IntervalToMilliseconds(endTime - startTime);
+    rate *= 1000;
+    rate /= (1024 * 1024);
+    printf("Wrote %7d bytes at a rate of %5.1f MB per second \n",
+           gTotalBytesWritten, rate);
+
+    return NS_OK;
+}
+
+nsresult NS_AutoregisterComponents()
+{
+  nsresult rv = nsComponentManager::AutoRegister(nsIComponentManager::NS_Startup,
+                                                 NULL /* default */);
+  return rv;
+}
+
+nsresult
+Test(nsINetDataCacheManager *aCache, PRUint32 aFlags, PRUint32 aCacheCapacity)
+{
+    nsresult rv;
+
+    rv = aCache->RemoveAll();
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't clear cache");
+
+    PRUint32 numEntries = (PRUint32)-1;
+    rv = aCache->GetNumEntries(&numEntries);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get number of cache entries");
+    NS_ASSERTION(numEntries == 0, "Couldn't clear cache");
+
+    rv = FillCache(aCache, aFlags, aCacheCapacity);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't fill cache with random test data");
+
+    rv = TestRead(aCache, aFlags);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't read random test data from cache");
+
+    rv = aCache->RemoveAll();
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't clear cache");
+
+    rv = aCache->GetNumEntries(&numEntries);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get number of cache entries");
+    NS_ASSERTION(numEntries == 0, "Couldn't clear cache");
+
+    return 0;
+}
+int
+main(int argc, char* argv[])
+{
+    nsresult rv;
+    nsCOMPtr<nsINetDataCacheManager> cache;
+
+    rv = NS_AutoregisterComponents();
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't register XPCOM components");
+
+    rv = nsComponentManager::CreateInstance(NS_NETWORK_CACHE_MANAGER_PROGID,
+                                            nsnull,
+                                            NS_GET_IID(nsINetDataCacheManager),
+                                            getter_AddRefs(cache));
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't create cache manager factory") ;
+
+    cache->SetDiskCacheCapacity(DISK_CACHE_CAPACITY);
+    cache->SetMemCacheCapacity(MEM_CACHE_CAPACITY);
+
+    InitQueue();
+    
+    Test(cache, nsINetDataCacheManager::BYPASS_PERSISTENT_CACHE, MEM_CACHE_CAPACITY);
+    Test(cache, nsINetDataCacheManager::BYPASS_MEMORY_CACHE, DISK_CACHE_CAPACITY);
+    return 0;
+}
+

mozilla/netwerk/test/TestRawCache.cpp

@@ -0,0 +1,820 @@
+/* -*- Mode: C++; tab-width: 2; 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 "nsIStreamListener.h"
+#include "nsIStreamObserver.h"
+#include "nsIServiceManager.h"
+#include "nsIInputStream.h"
+#include "nsIOutputStream.h"
+#include "nsIEventQueue.h"
+#include "nsIEventQueueService.h"
+#include "nsIChannel.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+#include <stdio.h>
+
+#include "nsINetDataCache.h"
+#include "nsINetDataDiskCache.h"
+#include "nsINetDataCacheRecord.h"
+#include "nsMemCacheCID.h"
+// file cache include
+#include "nsNetDiskCacheCID.h"
+#include "nsIPref.h"
+#include "prenv.h"
+#include "nsIFileStream.h"
+
+
+// Number of test entries to be placed in the cache
+#define NUM_CACHE_ENTRIES  250
+
+// Cache content stream length will have random length between zero and
+// MAX_CONTENT_LENGTH bytes
+#define MAX_CONTENT_LENGTH 20000
+
+// Length of random-data cache entry key
+#define CACHE_KEY_LENGTH 15
+
+// Length of random-data cache entry meta-data
+#define CACHE_METADATA_LENGTH 100
+
+static NS_DEFINE_CID(kMemCacheCID, NS_MEM_CACHE_FACTORY_CID);
+static NS_DEFINE_CID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID);
+
+// file cache cid
+static NS_DEFINE_CID(kDiskCacheCID, NS_NETDISKCACHE_CID) ;
+static NS_DEFINE_CID(kPrefCID, NS_PREF_CID);
+static NS_DEFINE_IID(kIPrefIID, NS_IPREF_IID);
+
+// Mapping from test case number to RecordID
+static PRInt32 recordID[NUM_CACHE_ENTRIES];
+
+static PRInt32
+mapRecordIdToTestNum(PRInt32 aRecordID)
+{
+    int i;
+    for (i = 0; i < NUM_CACHE_ENTRIES; i++) {
+        if (recordID[i] == aRecordID)
+            return i;
+    }
+    return -1;
+}
+
+// A supply of stream data to either store or compare with
+class nsITestDataStream {
+public:
+    virtual ~nsITestDataStream() {};
+    virtual PRUint32 Next() = 0;
+    virtual void Read(char* aBuf, PRUint32 aCount) = 0;
+
+    virtual PRBool Match(char* aBuf, PRUint32 aCount) = 0;
+    virtual void Skip(PRUint32 aCount) = 0;
+};
+
+// A reproducible stream of random data.
+class RandomStream : public nsITestDataStream {
+public:
+    RandomStream(PRUint32 aSeed) {
+        mStartSeed = mState = aSeed;
+    }
+    
+    PRUint32 GetStartSeed() {
+        return mStartSeed;
+    }
+    
+    PRUint32 Next() {
+        mState = 1103515245 * mState + 12345;
+        return mState;
+    }
+
+    void Read(char* aBuf, PRUint32 aCount) {
+        PRUint32 i;
+        for (i = 0; i < aCount; i++) {
+            *aBuf++ = Next();
+        }
+    }
+
+    PRBool
+    Match(char* aBuf, PRUint32 aCount) {
+        PRUint32 i;
+        for (i = 0; i < aCount; i++) {
+            if (*aBuf++ != (char)(Next() & 0xff))
+                return PR_FALSE;
+        }
+        return PR_TRUE;
+    }
+
+    void
+    Skip(PRUint32 aCount) {
+        while (aCount--)
+            Next();
+    }
+
+protected:
+    
+    PRUint32 mState;
+    PRUint32 mStartSeed;
+};
+
+// A stream of data that increments on each byte that is read, modulo 256
+class CounterStream : public nsITestDataStream {
+public:
+    CounterStream(PRUint32 aSeed) {
+        mStartSeed = mState = aSeed;
+    }
+    
+    PRUint32 GetStartSeed() {
+        return mStartSeed;
+    }
+    
+    PRUint32 Next() {
+        mState += 1;
+        mState &= 0xff;
+        return mState;
+    }
+
+    void Read(char* aBuf, PRUint32 aCount) {
+        PRUint32 i;
+        for (i = 0; i < aCount; i++) {
+            *aBuf++ = Next();
+        }
+    }
+
+    PRBool
+    Match(char* aBuf, PRUint32 aCount) {
+        PRUint32 i;
+        for (i = 0; i < aCount; i++) {
+            if (*aBuf++ != (char)Next())
+                return PR_FALSE;
+        }
+        return PR_TRUE;
+    }
+
+    void
+    Skip(PRUint32 aCount) {
+        mState += aCount;
+        mState &= 0xff;
+    }
+
+protected:
+    
+    PRUint32 mState;
+    PRUint32 mStartSeed;
+};
+
+static int gNumReaders = 0;
+static PRUint32 gTotalBytesRead = 0;
+static PRUint32 gTotalDuration = 0;
+
+class nsReader : public nsIStreamListener {
+public:
+    NS_DECL_ISUPPORTS
+
+    nsReader()
+        : mStartTime(0), mBytesRead(0)
+    {
+        NS_INIT_REFCNT();
+        gNumReaders++;
+    }
+
+    virtual ~nsReader() {
+        delete mTestDataStream;
+        gNumReaders--;
+    }
+
+    nsresult 
+    Init(nsITestDataStream* aRandomStream, PRUint32 aExpectedStreamLength) {
+        mTestDataStream = aRandomStream;
+        mExpectedStreamLength = aExpectedStreamLength;
+        mRefCnt = 1;
+        return NS_OK;
+    }
+
+    NS_IMETHOD OnStartRequest(nsIChannel* channel,
+                              nsISupports* context) {
+        mStartTime = PR_IntervalNow();
+        return NS_OK;
+    }
+
+    NS_IMETHOD OnDataAvailable(nsIChannel* channel, 
+                               nsISupports* context,
+                               nsIInputStream *aIStream, 
+                               PRUint32 aSourceOffset,
+                               PRUint32 aLength) {
+        char buf[1025];
+        while (aLength > 0) {
+            PRUint32 amt;
+            PRBool match;
+            aIStream->Read(buf, sizeof buf, &amt);
+            if (amt == 0) break;
+            aLength -= amt;
+            mBytesRead += amt;
+            match = mTestDataStream->Match(buf, amt);
+            NS_ASSERTION(match, "Stored data was corrupted on read");
+        }
+        return NS_OK;
+    }
+
+    NS_IMETHOD OnStopRequest(nsIChannel* channel, 
+                             nsISupports* context,
+                             nsresult aStatus,
+                             const PRUnichar* aMsg) {
+        PRIntervalTime endTime;
+        PRIntervalTime duration;
+        
+        endTime = PR_IntervalNow();
+        duration = (endTime - mStartTime);
+
+        if (NS_FAILED(aStatus)) printf("channel failed.\n");
+        //        printf("read %d bytes\n", mBytesRead);
+
+        NS_ASSERTION(mBytesRead == mExpectedStreamLength,
+                     "Stream in cache is wrong length");
+
+        gTotalBytesRead += mBytesRead;
+        gTotalDuration += duration;
+
+        return NS_OK;
+    }
+
+protected:
+    PRIntervalTime       mStartTime;
+    PRUint32             mBytesRead;
+    nsITestDataStream*   mTestDataStream;
+    PRUint32             mExpectedStreamLength;
+};
+
+NS_IMPL_ISUPPORTS2(nsReader, nsIStreamListener, nsIStreamObserver)
+
+static nsIEventQueue* eventQueue;
+
+nsresult
+InitQueue() {
+    nsresult rv;
+
+    NS_WITH_SERVICE(nsIEventQueueService, eventQService, kEventQueueServiceCID, &rv);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get event queue service");
+
+    rv = eventQService->CreateThreadEventQueue();
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't create event queue");
+  
+    rv = eventQService->GetThreadEventQueue(PR_CurrentThread(), &eventQueue);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get event queue for main thread");
+
+    return NS_OK;
+}
+
+// Process events until all streams are OnStopRequest'ed
+nsresult
+WaitForEvents() {
+    while (gNumReaders) {
+        eventQueue->ProcessPendingEvents();
+    }
+    return NS_OK;
+}
+
+// Read data for a single cache record and compare against testDataStream
+nsresult
+TestReadStream(nsINetDataCacheRecord *record, nsITestDataStream *testDataStream,
+               PRUint32 expectedStreamLength)
+{
+    nsCOMPtr<nsIChannel> channel;
+    nsresult rv;
+    PRUint32 actualContentLength;
+
+    rv = record->NewChannel(0, getter_AddRefs(channel));
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+    rv = record->GetStoredContentLength(&actualContentLength);
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+    NS_ASSERTION(actualContentLength == expectedStreamLength,
+                 "nsINetDataCacheRecord::GetContentLength() busted ?");
+    
+    nsReader *reader = new nsReader;
+    rv = reader->Init(testDataStream, expectedStreamLength);
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+    
+    rv = channel->AsyncRead(0, -1, 0, reader);
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+    reader->Release();
+
+    return NS_OK;
+}
+
+// Check that records can be retrieved using their record-ID, in addition
+// to using the opaque key.
+nsresult
+TestRecordID(nsINetDataCache *cache)
+{
+    nsresult rv;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    RandomStream *randomStream;
+    PRUint32 metaDataLength;
+    char cacheKey[CACHE_KEY_LENGTH];
+    char *metaData;
+    PRUint32 testNum;
+    PRBool match;
+
+    for (testNum = 0; testNum < NUM_CACHE_ENTRIES; testNum++) {
+        randomStream = new RandomStream(testNum);
+        randomStream->Read(cacheKey, sizeof cacheKey);
+
+        rv = cache->GetCachedNetDataByID(recordID[testNum], getter_AddRefs(record));
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't obtain record using record ID");
+
+        // Match against previously stored meta-data
+        rv = record->GetMetaData(&metaDataLength, &metaData);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get record meta-data");
+        match = randomStream->Match(metaData, metaDataLength);
+        NS_ASSERTION(match, "Meta-data corrupted or incorrect");
+
+        nsAllocator::Free(metaData);
+        delete randomStream;
+    }
+    return NS_OK;
+}
+
+// Check that all cache entries in the database are enumerated and that
+// no duplicates appear.
+nsresult
+TestEnumeration(nsINetDataCache *cache)
+{
+    nsresult rv;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    nsCOMPtr<nsISupports> tempISupports;
+    nsCOMPtr<nsISimpleEnumerator> iterator;
+    RandomStream *randomStream;
+    PRUint32 metaDataLength;
+    char cacheKey[CACHE_KEY_LENGTH];
+    char *metaData;
+    PRUint32 testNum;
+    PRBool match;
+    PRInt32 recID;
+
+    int numRecords = 0;
+
+    // Iterate over all records in the cache
+    rv = cache->NewCacheEntryIterator(getter_AddRefs(iterator));
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't create new cache entry iterator");
+
+    PRBool notDone;
+    while (1) {
+
+        // Done iterating ?
+        rv = iterator->HasMoreElements(&notDone);
+        if (NS_FAILED(rv)) return rv;
+        if (!notDone)
+            break;
+
+        // Get next record in iteration
+        rv = iterator->GetNext(getter_AddRefs(tempISupports));
+        NS_ASSERTION(NS_SUCCEEDED(rv), "iterator bustage");
+        record = do_QueryInterface(tempISupports);
+
+        numRecords++;
+
+        // Get record ID
+        rv = record->GetRecordID(&recID);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get Record ID");
+        testNum = mapRecordIdToTestNum(recID);
+        NS_ASSERTION(testNum != -1, "Corrupted Record ID ?");
+
+        // Erase mapping from table, so that duplicate enumerations are detected
+        recordID[testNum] = -1;
+
+        // Make sure stream matches test data
+        randomStream = new RandomStream(testNum);
+        randomStream->Read(cacheKey, sizeof cacheKey);
+
+        // Match against previously stored meta-data
+        rv = record->GetMetaData(&metaDataLength, &metaData);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get record meta-data");
+        match = randomStream->Match(metaData, metaDataLength);
+        NS_ASSERTION(match, "Meta-data corrupted or incorrect");
+        nsAllocator::Free(metaData);
+
+        delete randomStream;
+    }
+
+    NS_ASSERTION(numRecords == NUM_CACHE_ENTRIES, "Iteration bug");
+
+    return NS_OK;
+}
+
+// Read the test data that was written in FillCache(), checking for
+// corruption, truncation.
+nsresult
+TestRead(nsINetDataCache *cache)
+{
+    nsresult rv;
+    PRBool inCache;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    RandomStream *randomStream;
+    PRUint32 metaDataLength;
+    char cacheKey[CACHE_KEY_LENGTH];
+    char *metaData, *storedCacheKey;
+    PRUint32 testNum, storedCacheKeyLength;
+    PRBool match;
+
+    for (testNum = 0; testNum < NUM_CACHE_ENTRIES; testNum++) {
+        randomStream = new RandomStream(testNum);
+        randomStream->Read(cacheKey, sizeof cacheKey);
+
+        // Ensure that entry is in the cache
+        rv = cache->Contains(cacheKey, sizeof cacheKey, &inCache);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        NS_ASSERTION(inCache, "nsINetDataCache::Contains error");
+        
+        rv = cache->GetCachedNetData(cacheKey, sizeof cacheKey, getter_AddRefs(record));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+        // Match against previously stored meta-data
+        match = record->GetMetaData(&metaDataLength, &metaData);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        match = randomStream->Match(metaData, metaDataLength);
+        NS_ASSERTION(match, "Meta-data corrupted or incorrect");
+        nsAllocator::Free(metaData);
+
+        // Test GetKey() method
+        rv = record->GetKey(&storedCacheKeyLength, &storedCacheKey);
+        NS_ASSERTION(NS_SUCCEEDED(rv) &&
+                     (storedCacheKeyLength == sizeof cacheKey) &&
+                     !memcmp(storedCacheKey, &cacheKey[0], sizeof cacheKey),
+                     "nsINetDataCacheRecord::GetKey failed");
+        nsAllocator::Free(storedCacheKey);
+
+        PRUint32 expectedStreamLength = randomStream->Next() % MAX_CONTENT_LENGTH;
+
+        TestReadStream(record, randomStream, expectedStreamLength);
+    }
+
+    WaitForEvents();
+
+    // Compute rate in MB/s
+    double rate = gTotalBytesRead / PR_IntervalToMilliseconds(gTotalDuration);
+    rate *= NUM_CACHE_ENTRIES;
+    rate *= 1000;
+    rate /= (1024 * 1024);
+    printf("Read %d bytes at a rate of %5.1f MB per second \n",
+           gTotalBytesRead, rate);
+
+    return NS_OK;
+}
+
+// Repeatedly call SetStoredContentLength() on a cache entry and make
+// read the stream's data to ensure that it's not corrupted by the effect
+nsresult
+TestTruncation(nsINetDataCache *cache)
+{
+    nsresult rv;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    RandomStream *randomStream;
+    char cacheKey[CACHE_KEY_LENGTH];
+
+    randomStream = new RandomStream(0);
+    randomStream->Read(cacheKey, sizeof cacheKey);
+
+    rv = cache->GetCachedNetData(cacheKey, sizeof cacheKey, getter_AddRefs(record));
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+    randomStream->Skip(CACHE_METADATA_LENGTH);
+    PRUint32 initialStreamLength = randomStream->Next() % MAX_CONTENT_LENGTH;
+    delete randomStream;
+
+    PRUint32 i;
+    PRUint32 delta = initialStreamLength / 64;
+    for (i = initialStreamLength; i >= delta; i -= delta) {
+        PRUint32 expectedStreamLength = i;
+
+        // Do the truncation
+        record->SetStoredContentLength(expectedStreamLength);
+        randomStream = new RandomStream(0);
+        randomStream->Skip(CACHE_KEY_LENGTH + CACHE_METADATA_LENGTH + 1);
+
+        PRUint32 afterContentLength;
+        rv = record->GetStoredContentLength(&afterContentLength);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+        NS_ASSERTION(afterContentLength == expectedStreamLength,
+                     "nsINetDataCacheRecord::SetContentLength() failed to truncate record");
+
+        TestReadStream(record, randomStream, expectedStreamLength);
+        WaitForEvents();
+    }
+
+    return NS_OK;
+}
+
+// Write known data to random offsets in a single cache entry and test
+// resulting stream for correctness.
+nsresult
+TestOffsetWrites(nsINetDataCache *cache)
+{
+    nsresult rv;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    nsCOMPtr<nsIChannel> channel;
+    nsCOMPtr<nsIOutputStream> outStream;
+    char buf[512];
+    char cacheKey[CACHE_KEY_LENGTH];
+    RandomStream *randomStream;
+
+    randomStream = new RandomStream(0);
+    randomStream->Read(cacheKey, sizeof cacheKey);
+
+    rv = cache->GetCachedNetData(cacheKey, sizeof cacheKey, getter_AddRefs(record));
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't access record via opaque cache key");
+
+
+    // Write buffer-fulls of data at random offsets into the cache entry.
+    // Data written is (offset % 0xff)
+    PRUint32 startingOffset;
+    PRUint32 streamLength = 0;
+    CounterStream *counterStream;
+    int i;
+    for (i = 0; i < 100; i++) {
+        rv = record->NewChannel(0, getter_AddRefs(channel));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+        startingOffset = streamLength ? streamLength - (randomStream->Next() % sizeof buf): 0;
+        rv = channel->OpenOutputStream(startingOffset, getter_AddRefs(outStream));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        
+        counterStream = new CounterStream(startingOffset);
+        counterStream->Read(buf, sizeof buf);
+
+        PRUint32 numWritten;
+        rv = outStream->Write(buf, sizeof buf, &numWritten);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        NS_ASSERTION(numWritten == sizeof buf, "Write() bug?");
+        streamLength = startingOffset + sizeof buf;
+
+        rv = outStream->Close();
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't close channel");
+        delete counterStream;
+    }
+    
+    delete randomStream;
+
+    counterStream = new CounterStream(0);
+    TestReadStream(record, counterStream, streamLength);
+    WaitForEvents();
+
+    return NS_OK;
+}
+
+// Create entries in the network data cache, using random data for the
+// key, the meta-data and the stored content data.
+nsresult
+FillCache(nsINetDataCache *cache)
+{
+    nsresult rv;
+    PRBool inCache;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    nsCOMPtr<nsIChannel> channel;
+    nsCOMPtr<nsIOutputStream> outStream;
+    char buf[1000];
+    PRUint32 metaDataLength;
+    char cacheKey[CACHE_KEY_LENGTH];
+    char metaData[CACHE_METADATA_LENGTH];
+    PRUint32 testNum;
+    char *data;
+    RandomStream *randomStream;
+    PRUint32 totalBytesWritten = 0;
+
+    PRIntervalTime startTime = PR_IntervalNow();
+    
+    for (testNum = 0; testNum < NUM_CACHE_ENTRIES; testNum++) {
+        randomStream = new RandomStream(testNum);
+        randomStream->Read(cacheKey, sizeof cacheKey);
+
+        // No entry should be in cache until we add it
+        rv = cache->Contains(cacheKey, sizeof cacheKey, &inCache);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        NS_ASSERTION(!inCache, "nsINetDataCache::Contains error");
+        
+        rv = cache->GetCachedNetData(cacheKey, sizeof cacheKey, getter_AddRefs(record));
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't access record via opaque cache key");
+
+        // Test nsINetDataCacheRecord::GetRecordID()
+        rv = record->GetRecordID(&recordID[testNum]);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get Record ID");
+
+        // Test nsINetDataCache::GetNumEntries()
+        PRUint32 numEntries = (PRUint32)-1;
+        rv = cache->GetNumEntries(&numEntries);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get number of cache entries");
+        NS_ASSERTION(numEntries == testNum + 1, "GetNumEntries failure");
+
+        // Record meta-data should be initially empty
+        rv = record->GetMetaData(&metaDataLength, &data);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        if ((metaDataLength != 0) || (data != 0))
+            return NS_ERROR_FAILURE;
+
+        // Store random data as meta-data
+        randomStream->Read(metaData, sizeof metaData);
+        record->SetMetaData(sizeof metaData, metaData);
+
+        rv = record->NewChannel(0, getter_AddRefs(channel));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+        rv = channel->OpenOutputStream(0, getter_AddRefs(outStream));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        
+        PRUint32 beforeOccupancy;
+        rv = cache->GetStorageInUse(&beforeOccupancy);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get cache occupancy");
+
+        int streamLength = randomStream->Next() % MAX_CONTENT_LENGTH;
+        int remaining = streamLength;
+        while (remaining) {
+            PRUint32 numWritten;
+            int amount = PR_MIN(sizeof buf, remaining);
+            randomStream->Read(buf, amount);
+
+            rv = outStream->Write(buf, amount, &numWritten);
+            NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+            NS_ASSERTION(numWritten == (PRUint32)amount, "Write() bug?");
+            
+            remaining -= amount;
+        }
+        outStream->Close();
+        totalBytesWritten += streamLength;
+
+        PRUint32 afterOccupancy;
+        rv = cache->GetStorageInUse(&afterOccupancy);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get cache occupancy");
+        PRUint32 streamLengthInKB = streamLength >> 10;
+        NS_ASSERTION((afterOccupancy - beforeOccupancy) >= streamLengthInKB,
+                     "nsINetDataCache::GetStorageInUse() is busted");
+        
+
+        // *Now* there should be an entry in the cache
+        rv = cache->Contains(cacheKey, sizeof cacheKey, &inCache);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        NS_ASSERTION(inCache, "nsINetDataCache::Contains error");
+
+        delete randomStream;
+    }
+
+    PRIntervalTime endTime = PR_IntervalNow();
+
+    // Compute rate in MB/s
+    double rate = totalBytesWritten / PR_IntervalToMilliseconds(endTime - startTime);
+    rate *= 1000;
+    rate /= (1024 * 1024);
+    printf("Wrote %7d bytes at a rate of %5.1f MB per second \n",
+           totalBytesWritten, rate);
+
+    return NS_OK;
+}
+
+nsresult NS_AutoregisterComponents()
+{
+  nsresult rv = nsComponentManager::AutoRegister(nsIComponentManager::NS_Startup,
+                                                 NULL /* default */);
+  return rv;
+}
+
+PRBool initPref ()
+{
+    nsresult rv;
+    NS_WITH_SERVICE(nsIPref, prefPtr, kPrefCID, &rv);
+    if (NS_FAILED(rv))
+        return false;
+               
+    nsCOMPtr<nsIFileSpec> fileSpec;
+    rv = NS_NewFileSpec (getter_AddRefs(fileSpec));
+    if (NS_FAILED(rv))
+        return false;
+                            
+    nsCString defaultPrefFile = PR_GetEnv ("MOZILLA_FIVE_HOME");
+    if (defaultPrefFile.Length())
+        defaultPrefFile += "/";
+    else
+        defaultPrefFile = "./";
+    defaultPrefFile += "default_prefs.js";
+                                                 
+    fileSpec->SetUnixStyleFilePath (defaultPrefFile.GetBuffer());
+                                                    
+    PRBool exists = false;
+    fileSpec->Exists(&exists);
+    if (exists)
+        prefPtr->ReadUserPrefsFrom(fileSpec);
+    else
+        return false;
+    return true;
+}
+
+int
+main(int argc, char* argv[])
+{
+    nsresult rv;
+
+    if(argc <2) {
+      printf(" %s -f to test filecache\n", argv[0]) ;
+      printf(" %s -m to test memcache\n", argv[0]) ;
+      return -1 ;
+    }
+
+
+    rv = NS_AutoregisterComponents();
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't register XPCOM components");
+
+    nsCOMPtr<nsINetDataCache> cache;
+
+    if (PL_strcasecmp(argv[1], "-m") == 0) {
+        rv = nsComponentManager::CreateInstance(kMemCacheCID, nsnull,
+                                            NS_GET_IID(nsINetDataCache),
+                                            getter_AddRefs(cache));
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't create memory cache factory");
+    } else if (PL_strcasecmp(argv[1], "-f") == 0) {
+
+        nsCOMPtr<nsINetDataDiskCache> diskcache ;
+
+        rv = nsComponentManager::CreateInstance(kDiskCacheCID, nsnull,
+                                            NS_GET_IID(nsINetDataDiskCache),
+                                             getter_AddRefs(diskcache));
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't create disk cache factory") ;
+        
+        nsCOMPtr<nsIFileSpec> folder ;
+        NS_NewFileSpec(getter_AddRefs(folder)) ;
+        folder->SetUnixStyleFilePath("/tmp") ;
+        diskcache->SetDiskCacheFolder(folder) ;
+
+        cache = diskcache ;
+
+    } else {
+      printf("  %s -f to test filecache\n", argv[0]) ;
+      printf(" %s -m to test memcache\n", argv[0]) ;
+      return -1 ;
+    }
+
+    InitQueue();
+
+    PRUnichar* description;
+    rv = cache->GetDescription(&description);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get cache description");
+    nsCAutoString descStr(description);
+    printf("Testing: %s\n", descStr.GetBuffer());
+
+    rv = cache->RemoveAll();
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't clear cache");
+
+    PRUint32 startOccupancy;
+    rv = cache->GetStorageInUse(&startOccupancy);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get cache occupancy");
+
+    PRUint32 numEntries = (PRUint32)-1;
+    rv = cache->GetNumEntries(&numEntries);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get number of cache entries");
+    NS_ASSERTION(numEntries == 0, "Couldn't clear cache");
+
+    rv = FillCache(cache);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't fill cache with random test data");
+
+    rv = TestRead(cache);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't read random test data from cache");
+
+    rv = TestRecordID(cache);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't index records using record ID");
+
+    rv = TestEnumeration(cache);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't successfully enumerate records");
+
+    rv = TestTruncation(cache);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't successfully truncate records");
+
+    rv = TestOffsetWrites(cache);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't successfully write to records using non-zero offsets");
+
+    rv = cache->RemoveAll();
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't clear cache");
+    rv = cache->GetNumEntries(&numEntries);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get number of cache entries");
+    NS_ASSERTION(numEntries == 0, "Couldn't clear cache");
+
+    PRUint32 endOccupancy;
+    rv = cache->GetStorageInUse(&endOccupancy);
+
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get cache occupancy");
+
+    NS_ASSERTION(startOccupancy == endOccupancy, "Cache occupancy not correctly computed ?");
+
+    return 0;
+}
+

mozilla/netwerk/test/makefile.win

@@ -0,0 +1,82 @@
+#!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=..\..
+
+MAKE_OBJ_TYPE	= EXE
+PROG1 = .\$(OBJDIR)\TestFileInput.exe
+PROG2 = .\$(OBJDIR)\TestSocketInput.exe
+PROG3 = .\$(OBJDIR)\TestSocketIO.exe
+PROG4 = .\$(OBJDIR)\TestProtocols.exe
+PROG5 = .\$(OBJDIR)\TestSocketTransport.exe
+PROG6 = .\$(OBJDIR)\urltest.exe
+PROG7 = .\$(OBJDIR)\TestFileInput2.exe
+PROG8 = .\$(OBJDIR)\TestFileTransport.exe
+PROG9 = .\$(OBJDIR)\TestRes.exe
+PROGA = .\$(OBJDIR)\TestRawCache.exe
+PROGB = .\$(OBJDIR)\TestCacheMgr.exe
+PROGRAMS = \
+#$(PROG1) $(PROG2) $(PROG3) $(PROG4) $(PROG5) $(PROG6) $(PROG7) $(PROG8) $(PROG9)\
+          $(PROGA) $(PROGB)
+
+LCFLAGS=-DUSE_NSREG -GX
+
+REQUIRES=libreg
+
+INCS = $(INCS)                  \
+        -I$(DEPTH)\dist\include \
+        $(NULL)
+
+LLIBS=                 \
+ $(DIST)\lib\xpcom.lib \
+ $(LIBNSPR)            \
+ $(NULL)
+
+include <$(DEPTH)\config\rules.mak>
+
+install:: $(PROGRAMS)
+	-for %p in ($(PROGRAMS)) do $(MAKE_INSTALL) %p $(DIST)\bin
+
+clobber::
+	-for %p in ($(PROGRAMS)) do $(RM) %p $(DIST)\bin\%p
+
+$(PROG1): $(OBJDIR) TestFileInput.cpp
+
+$(PROG2): $(OBJDIR) TestSocketInput.cpp
+
+$(PROG3): $(OBJDIR) TestSocketIO.cpp
+
+$(PROG4): $(OBJDIR) TestProtocols.cpp
+
+$(PROG5): $(OBJDIR) TestSocketTransport.cpp
+
+$(PROG6): $(OBJDIR) urltest.cpp
+
+$(PROG7): $(OBJDIR) TestFileInput2.cpp
+
+$(PROG8): $(OBJDIR) TestFileTransport.cpp
+
+$(PROG9): $(OBJDIR) TestRes.cpp
+
+$(PROGA): $(OBJDIR) TestRawCache.cpp
+
+$(PROGB): $(OBJDIR) TestCacheMgr.cpp
+

mozilla/security/psm/Makefile

@@ -1,88 +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).                              #
-#######################################################################
-
-psm_RelEng_srvr_bld:
-	cd ../coreconf; gmake
-	cd ../../nsprpub; $(MAKE) OBJDIR_NAME=$(OBJDIR_NAME)
-	cd ../nss; gmake import IMPORTS=dbm/DBM_1_54
-	cd ../nss; gmake 
-ifeq ($(OS_ARCH), WINNT)
-	gmake import IMPORTS=nlslayer/m16
-else
-	gmake import IMPORTS=nlslayer/PR3 RELEASE_TREE=/h/tortoise/export/share/builds/components
-endif
-	cd ui;gmake
-	gmake
-	cd server;gmake build_xpi
-

mozilla/security/psm/Makefile.in

@@ -1,118 +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@
-
-
-CORE_DEPTH=$(topsrcdir)/security
-
-include $(CORE_DEPTH)/coreconf/arch.mk
-ifeq (,$(filter-out NetBSD,$(OS_TARGET)))
-include $(CORE_DEPTH)/coreconf/$(OS_TARGET).mk
-else
-include $(CORE_DEPTH)/coreconf/$(OS_CONFIG).mk
-endif
-include $(CORE_DEPTH)/coreconf/prefix.mk
-CPU_TAG = _$(CPU_ARCH)
-LOADABLE_ROOT_MODULE = $(DLL_PREFIX)nssckbi$(DLL_SUFFIX)
-CORECONF_OBJDIR=$(OBJDIR_NAME)
-
-include $(DEPTH)/config/autoconf.mk
-
-ifndef MOZ_DEBUG
-OPT_GMAKE_FLAGS = BUILD_OPT=1
-BUILD_OPT=1
-OBJDIR_TAG=_OPT
-endif
-
-DEFAULT_GMAKE_FLAGS = -f Makefile $(OPT_GMAKE_FLAGS) 
-
-CORECONF_INSTALL     = $(DIST)/$(CORECONF_OBJDIR)
-CORECONF_DIST        = $(MOZ_BUILD_ROOT)/dist/$(CORECONF_OBJDIR)
-DEFAULT_GMAKE_FLAGS += DIST=$(CORECONF_DIST) 
-DEFAULT_GMAKE_FLAGS += SOURCE_LIB_DIR=$(CORECONF_DIST)/lib
-DEFAULT_GMAKE_FLAGS += SOURCE_BIN_DIR=$(CORECONF_DIST)/bin
-DEFAULT_GMAKE_FLAGS += SOURCE_XP_DIR=$(CORECONF_DIST)
-
-
-DIRS		= lib
-
-include $(topsrcdir)/config/rules.mk
-
-ABS_topsrcdir	:= $(shell cd $(topsrcdir); pwd)
-
-install::
-ifneq ($(ABS_topsrcdir),$(MOZ_BUILD_ROOT))
-	if test ! -d $(MOZ_BUILD_ROOT)/security/nss; then                   \
-		cp -r $(topsrcdir)/security/nss $(MOZ_BUILD_ROOT)/security; \
-	fi;
-	if test ! -d $(MOZ_BUILD_ROOT)/security/coreconf; then              \
-		cp -r $(topsrcdir)/security/coreconf $(MOZ_BUILD_ROOT)/security; \
-	fi;
-	if test ! -d $(MOZ_BUILD_ROOT)/security/psm/server; then            \
-		cp -r $(topsrcdir)/security/psm/server $(MOZ_BUILD_ROOT)/security/psm/server; \
-	fi;
-	if test ! -d $(MOZ_BUILD_ROOT)/security/psm/ui; then        \
-		cp -r $(topsrcdir)/security/psm/ui $(MOZ_BUILD_ROOT)/security/psm/; \
-	fi;
-	if test ! -d $(MOZ_BUILD_ROOT)/security/psm/doc; then       \
-		cp -r $(topsrcdir)/security/psm/doc $(MOZ_BUILD_ROOT)/security/psm/; \
-	fi;
-endif
-	cd $(MOZ_BUILD_ROOT)/security/coreconf; gmake $(DEFAULT_GMAKE_FLAGS)
-	cd $(MOZ_BUILD_ROOT)/security/nss; gmake $(DEFAULT_GMAKE_FLAGS) moz_import
-	cd $(MOZ_BUILD_ROOT)/security/nss/lib; gmake $(DEFAULT_GMAKE_FLAGS)
-	cd $(MOZ_BUILD_ROOT)/security/psm/ui; gmake $(DEFAULT_GMAKE_FLAGS)
-	cd $(MOZ_BUILD_ROOT)/security/psm/server; gmake $(DEFAULT_GMAKE_FLAGS)
-	$(INSTALL) -m 755 $(CORECONF_INSTALL)/bin/psm $(DIST)/bin/
-	$(INSTALL) -m 755 $(CORECONF_INSTALL)/bin/psmdata $(DIST)/bin
-	$(INSTALL) -m 755 $(CORECONF_INSTALL)/bin/start-psm $(DIST)/bin
-	$(INSTALL) -m 755 $(CORECONF_INSTALL)/lib/$(LOADABLE_ROOT_MODULE) $(DIST)/bin
-
-clean clobber clobber_all realclean distclean::
-ifeq ($(ABS_topsrcdir),$(MOZ_BUILD_ROOT))
-	cd $(MOZ_BUILD_ROOT)/security/coreconf; gmake $(DEFAULT_GMAKE_FLAGS) clean
-	cd $(MOZ_BUILD_ROOT)/security/nss; gmake $(DEFAULT_GMAKE_FLAGS) clean
-	cd $(MOZ_BUILD_ROOT)/security/psm/ui; gmake $(DEFAULT_GMAKE_FLAGS) clean
-	cd $(MOZ_BUILD_ROOT)/security/psm/server; gmake $(DEFAULT_GMAKE_FLAGS) clean
-else
-	if test -d $(MOZ_BUILD_ROOT)/security/nss; then \
-		rm -rf $(MOZ_BUILD_ROOT)/security/nss;  \
-	fi;
-	if test -d $(MOZ_BUILD_ROOT)/security/coreconf; then    \
-		rm -rf $(MOZ_BUILD_ROOT)/security/coreconf;     \
-	fi;
-	if test -d $(MOZ_BUILD_ROOT)/security/psm/server; then  \
-		rm -rf $(MOZ_BUILD_ROOT)/security/psm/server;   \
-	fi;
-	if test -d $(MOZ_BUILD_ROOT)/security/psm/ui; then      \
-		rm -rf $(MOZ_BUILD_ROOT)/security/psm/ui;       \
-	fi;
-	if test -d $(MOZ_BUILD_ROOT)/security/psm/doc; then     \
-		rm -rf $(MOZ_BUILD_ROOT)/security/psm/doc;      \
-	fi;
-	if test -d $(MOZ_BUILD_ROOT)/dist/$(CORECONF_OBJDIR); then      \
-		rm -rf $(MOZ_BUILD_ROOT)/dist/$(CORECONF_OBJDIR);       \
-	fi;
-endif

mozilla/security/psm/doc/cmcjavascriptapi.html

@@ -1,494 +0,0 @@
-<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
-<html>
-<head>
-   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-   <meta name="GENERATOR" content="Mozilla/4.7 [en] (WinNT; U) [Netscape]">
-   <title>Javascript API for Client Certificate Management</title>
-</head>
-<body>
-<h2><font face="Arial,Helvetica">Netscape Personal Security Manager</font></h2>
-
-<h2><font face="Arial,Helvetica">JavaScript API for Client Certificate Management</font></h2>
-
-Version 0.3 - 10/27/1999
-<br>Comments to: <a href="mailto:psmfeedback@netscape.com?subject=JavaScript%20API%20Feedback">psmfeedback@netscape.com</a>
-<p>This document describes a new JavaScript API for performing user certificate
-management operations within a client. The JavaScript runs in the context
-of a web page operated by a Certificate Authority (CA) or Registration
-Authority (RA). The API allows the CA or RA to instruct the client to perform
-PKI operations such as key generation, certificate request generation,
-key escrow, import of user certificates, key recovery, and revocation requests.
-<p>These properties and methods reflect behavior currently implemented
-in Personal Security Manager 1.0.
-<p>The messages imported by or generated by these JavaScript methods are
-defined in the CRMF, CMMF, and CMC internet drafts.
-<h2>
-<font face="Arial,Helvetica">Overview of New Cert Issuing Process</font></h2>
-
-<ol>
-<li>
-User fills out enrollment form</li>
-
-<li>
-User action initiates script</li>
-
-<li>
-Script calls key generation method</li>
-
-<li>
-Signing and Encryption keys are generated</li>
-
-<li>
-Encryption Private Key is wrapped with public key of Key Recovery Authority
-(KRA) (passed in in the form of a certificate as part of the script, and
-checked against a pre-installed certificate copy in the local certificate
-database)</li>
-
-<li>
-The public keys, wrapped encryption private key, and text string from the
-script (possibly containing naming or enrollment info) are signed by the
-user</li>
-
-<li>
-Signed blob is returned to the script</li>
-
-<li>
-Script submits signed blob and any other necessary info to the CA/RA</li>
-
-<li>
-CA/RA verifies signature on signed blob</li>
-
-<li>
-CA/RA validates identity of user</li>
-
-<li>
-CA/RA sends wrapped encryption private key to KRA</li>
-
-<li>
-KRA sends escrow verification back to CA</li>
-
-<li>
-CA creates and signs certificates</li>
-
-<li>
-CA sends certificates back to Communicator</li>
-</ol>
-
-<h2>
-<font face="Arial,Helvetica">JavaScript API</font></h2>
-
-<h3>
-<font face="Arial,Helvetica">Properties</font></h3>
-<tt>crypto.algorithms.dh.keySizes</tt>
-<br><tt>crypto.algorithms.dsa.keySizes</tt>
-<br><tt>crypto.algorithms.rsa.signing.keySizes</tt>
-<br><tt>crypto.algorithms.rsa.keyEx.keySizes</tt>
-<p><tt>keySizes</tt> is an an array that describes the available key sizes
-for the particular algorithms and operations.
-<p>The table below describes the key sizes that will be supported in the
-US and Export versions of Communicator.
-<br>&nbsp;
-<table BORDER WIDTH="100%" >
-<tr>
-<td ALIGN=CENTER><b>Algorithm</b></td>
-
-<td ALIGN=CENTER><b>US Version Key Sizes</b></td>
-
-<td ALIGN=CENTER><b>Export Version Key Sizes</b></td>
-</tr>
-
-<tr>
-<td>DSA Signing Only</td>
-
-<td>1024, 2048</td>
-
-<td>1024, 2048</td>
-</tr>
-
-<tr>
-<td>RSA Signing Only</td>
-
-<td>1024, 2048</td>
-
-<td>1024, 2048</td>
-</tr>
-
-<tr>
-<td>RSA Encryption Only</td>
-
-<td>1024, 2048</td>
-
-<td>512,1024</td>
-</tr>
-
-<tr>
-<td>RSA Dual Use Signing And Encryption</td>
-
-<td>1024, 2048</td>
-
-<td>512,1024</td>
-</tr>
-
-<tr>
-<td>DH Key Exchange</td>
-
-<td>1024, 2048</td>
-
-<td>512,1024</td>
-</tr>
-</table>
-
-<h3>
-<font face="Arial,Helvetica">Methods</font></h3>
-
-<h4>
-<font face="Arial,Helvetica">generateCRMFRequest()</font></h4>
-<tt>crmfObject = crypto.generateCRMFRequest(<i>"requestedDN", "regToken",
-"authenticator","escrowAuthorityCert", "KeyGen Done Code",keySize1, "keyParams1",
-"keyGenAlg1",..., keySizeN, "keyParamsN", "keyGenAlgN");</i></tt>
-<p>This method will generate a sequence of CRMF requests that has N requests.&nbsp;
-One request for each key pair that is generated.&nbsp; The first three
-parameters will be applied to every request.&nbsp; the "escrowAuthorityCert"
-parameter will only be used for requests that pertain to a key that is
-being escrowed.&nbsp; After the "escrowAuthorityCert" parameter, the method
-takes some JavaScript code that&nbsp; is invoked when the CRMF request
-is ready. Finally, there are 1 or more sets of key generation arguments.&nbsp;
-Each key generation will be associated with its own request.&nbsp; All
-the requests will have the same DN.
-<br>&nbsp;
-<table BORDER WIDTH="100%" >
-<tr>
-<td ALIGN=CENTER VALIGN=TOP><b>Argument</b></td>
-
-<td ALIGN=CENTER><b>Description</b></td>
-</tr>
-
-<tr>
-<td><i><tt>"requestedDN"</tt></i></td>
-
-<td>An RFC1485 formatted DN to include in the certificate request.</td>
-</tr>
-
-<tr>
-<td><i><tt>"regToken"</tt></i></td>
-
-<td>A value used to authenticate the user to the RA/CA.</td>
-</tr>
-
-<tr>
-<td><i><tt>"authenticator"</tt></i></td>
-
-<td>A value that the user can authenticate with in the future when their
-private key is not available. Can be used for key recovery or revocation
-requests.</td>
-</tr>
-
-<tr>
-<td><i><tt>"escrowAuthorityCert"</tt></i></td>
-
-<td>If this value is NULL, then no key escrow will be performed. This value
-specifies which KRA certificate should be used to wrap the private key
-being escrowed. The user will be prompted for confirmation whenever a key
-will be escrowed.&nbsp; Only key exchange keys will be escrowed. If a dual
-use key is being generated, it will not be escrowed.&nbsp; The value of
-this argument is a base-64 encoded certificate.</td>
-</tr>
-
-<tr>
-<td><i><tt>"CRMF Generation Done Code"</tt></i></td>
-
-<td>This parameter is JavaScript to execute when the CRMF generation is
-complete.&nbsp;</td>
-</tr>
-
-<tr>
-<td VALIGN=TOP><i><tt>keySizeN</tt></i></td>
-
-<td>The size in bits of the Nth key to generate</td>
-</tr>
-
-<tr>
-<td VALIGN=TOP><i><tt>"keyParamsN"</tt></i></td>
-
-<td>This string is an optional algorithm dependent parameter value. For
-Diffie-Hellman it is used to specify p and g parameters.&nbsp; For DSA,
-it will be used to specify pqg. If the key generation requires parameters
-and the value passed in is NULL, then the client will generate the parameters
-on its own. Currently, this value is ignored.</td>
-</tr>
-
-<tr>
-<td VALIGN=TOP><i><tt>"keyGenAlgN"</tt></i></td>
-
-<td>Which algorithm the generated key will support. Acceptable values are
-(the mentioned values for keyUsage pertain to the keyUsage value of the
-Certificate Extension that will ultimately be in the issued certificate):&nbsp;
-<ul>
-<li>
-"rsa-ex" - generate an RSA key for key exchange only (This will have keyEncipherment
-set for keyUsage.)</li>
-
-<li>
-"rsa-dual-use" - generate a single RSA key for both signing and encryption.&nbsp;
-(This will have digitalSignature, keyEncipherment, and nonRepudiation set
-for keyUsage.)</li>
-
-<li>
-"rsa-sign" - generate an RSA key for signing only. (This will have digitalSignature
-set for keyUsage.)</li>
-
-<li>
-"rsa-nonrepudiation" - generate a single RSA key for nonRepudiation only.
-(This will have non-repudiation set for keyUsage.)</li>
-
-<li>
-"rsa-sign-nonrepudiation" - generate a single RSA key use for both signing
-and nonRepudiation. (This will have both digitalSignature and nonRepudiation
-set for keyUsage.)</li>
-
-<li>
-"dsa-sign" - generate a single DSA key for signing only. (This will have
-digitalSignature set for keyUsage.)</li>
-
-<li>
-"dsa-nonrepudiation" - generate a single DSA key for nonRepudiation. (This
-will have nonRepudiation set for keyUsage.)</li>
-
-<li>
-"dsa-sign-nonrepudiation" - generate a single DSA key for signing and non-repudiation.
-(This will have digitalSignature and nonRepudiation set for keyUsage.)</li>
-</ul>
-</td>
-</tr>
-</table>
-
-<p>The <b>generateCRMFRequest()</b> method will cause the user to be presented
-with a key generation dialog. The dialog describes the key generation process
-and gives the user the opportunity to cancel the operation.
-<p>The method <b>generateCRMFRequest() </b>will return an instance of a
-CRMF object. The JavaScript passed in as the <i><tt>"CRMF Generation Done
-Code"</tt></i> parameter should look at the attribute <i>request </i>of
-the returned object to get the result of the CRMF generation.
-<p>The string found by accessing <i><tt>crmfObject.request</tt></i> is
-the base-64 encoded CRMF message to be sent to the CA/RA, or an error string.
-The possible error strings are:
-<br>&nbsp;
-<table BORDER WIDTH="100%" >
-<tr>
-<td ALIGN=CENTER><b>Error String</b></td>
-
-<td ALIGN=CENTER><b>Description</b></td>
-</tr>
-
-<tr>
-<td>"error:invalidParameter:XXX"</td>
-
-<td>The parameter XXX was an invalid value.</td>
-</tr>
-
-<tr>
-<td>"error:userCancel"</td>
-
-<td>the user has canceled the key generation operation</td>
-</tr>
-
-<tr>
-<td>"error:internalError"</td>
-
-<td>the software encountered some internal error, such as out of memory</td>
-</tr>
-</table>
-
-<h4>
-<font face="Arial,Helvetica">importUserCertificates()</font></h4>
-<tt><i>resultString</i> = crypto.importUserCertificates(<i>"nicknameString"</i>,
-<i>"certString"</i>,
-<i>allowBackup</i>)</tt>
-<br>&nbsp;
-<br>&nbsp;
-<table BORDER WIDTH="100%" >
-<tr>
-<td ALIGN=CENTER><b>Argument</b></td>
-
-<td ALIGN=CENTER><b>Description</b></td>
-</tr>
-
-<tr>
-<td VALIGN=TOP><i><tt>"nicknameString"</tt></i></td>
-
-<td>This is the nickname that will be used to describe the certificate
-in the client's certificate management UI.&nbsp; It should serve to uniquely
-identify the certificate to the user. For example, "John Smith's VeriSign
-Class 3 Digital ID" or "John Smith's Ford ID Certificate". However, if
-this certificate has the same DN as one or more certificates that already
-exist in the user's certificate store, the nickname associated with the
-certificate(s) of the same DN in the certificate store is used, and the
-<tt>"nicknameString"</tt> parameter is ignored. If the string is null and
-no certificate with the same DN exists in the user's certificate store,
-Personal Security Manager uses the following pattern to derive the nickname:
-<tt>&lt;Common Name>'s &lt;Issuer Name> ID</tt>.</td>
-</tr>
-
-<tr>
-<td VALIGN=TOP><i><tt>"certRepString"</tt></i></td>
-
-<td>This string is the CMMF Certification Response from the CA that contains
-the user's certificate(s). The response is base-64 encoded.</td>
-</tr>
-
-<tr>
-<td><i><tt>allowBackup</tt></i></td>
-
-<td>This is a Boolean argument. It allows the CA or RA to indicate to the
-client whether to force the user to back up a newly issued certificate
-(PKCS #12).</td>
-</tr>
-</table>
-
-<p>The <b>importUserCertificates()</b> method is used to import newly issued
-certificates for the user. The private key for the certificates must already
-reside in the user's personal private key database.
-<p>The request ID in the response being imported must match the request
-ID in the associated Certification Request or Recovery Request.
-<p>If the import operation succeeds, an empty string will be returned.&nbsp;
-If it fails, one of the following error strings will be returned:
-<br>&nbsp;
-<br>&nbsp;
-<table BORDER WIDTH="100%" >
-<tr>
-<td ALIGN=CENTER><b>Error String</b></td>
-
-<td ALIGN=CENTER><b>Description</b></td>
-</tr>
-
-<tr>
-<td>"error:userCancel"</td>
-
-<td>The user canceled the import operation</td>
-</tr>
-
-<tr>
-<td>"error:invalidCertificate"</td>
-
-<td>One of the certificate packages was incorrectly formatted</td>
-</tr>
-
-<tr>
-<td>"error:internalError"</td>
-
-<td>The software encountered some internal error, such as out of memory</td>
-</tr>
-
-<tr>
-<td>"error:invalidRequestID"</td>
-
-<td>The request ID in the response message does not match any outstanding
-request</td>
-</tr>
-</table>
-
-<h4>
-<font face="Arial,Helvetica">popChallengeResponse()</font></h4>
-<tt><i>resultString</i> = crypto.popChallengeResponse(<i>"challengeString"</i>);</tt>
-<br>&nbsp;
-<table BORDER WIDTH="100%" >
-<tr>
-<td ALIGN=CENTER VALIGN=TOP><b>Argument</b></td>
-
-<td ALIGN=CENTER><b>Description</b></td>
-</tr>
-
-<tr>
-<td VALIGN=TOP><i><tt>"challengeString"</tt></i></td>
-
-<td>A base-64 encoded CMMF POPODecKeyChallContent message. The current
-implementation does not conform to that defined in the CMMF draft, and
-we intend to change this implementation to that defined in the CMC RFC..
-See below for the current implementation.</td>
-</tr>
-</table>
-
-<p>The resultString will either be a base-64 encoded POPODecKeyRespContent
-message, or one of the following error strings:
-<br>&nbsp;
-<br>&nbsp;
-<table BORDER WIDTH="100%" >
-<tr>
-<td ALIGN=CENTER><b>Error String</b></td>
-
-<td ALIGN=CENTER><b>Description</b></td>
-</tr>
-
-<tr>
-<td>"error:invalidParameter:XXX"</td>
-
-<td>The parameter XXX was an invalid value.</td>
-</tr>
-
-<tr>
-<td>"error:internalError"</td>
-
-<td>the software encountered some internal error, such as out of memory</td>
-</tr>
-</table>
-
-<p><b>Challenge-Response Proof Of Possession</b>
-<p><tt>Expected Input:</tt>
-<p><tt>POPODecKeyChallContent ::= SEQUENCE OF Challenge</tt>
-<br><tt>&nbsp;&nbsp;&nbsp; -- One Challenge per encryption key certification
-request (in the</tt>
-<br><tt>&nbsp;&nbsp;&nbsp; -- same order as these requests appear in FullCertTemplates).</tt>
-<p><tt>Challenge ::= SEQUENCE {</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; owf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
-AlgorithmIdentifier&nbsp; OPTIONAL,</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; -- MUST be present in the first
-Challenge; MAY be omitted in any</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; -- subsequent Challenge in POPODecKeyChallContent
-(if omitted,</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; -- then the owf used in the immediately
-preceding Challenge is</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; -- to be used).</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; witness&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
-OCTET STRING,</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; -- the result of applying the one-way
-function (owf) to a</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; -- randomly-generated INTEGER, A.&nbsp;
-[Note that a different</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; -- INTEGER MUST be used for each
-Challenge.]</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; sender&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
-GeneralName,</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; -- the name of the sender.</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; key&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
-OCTET STRING,</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; -- the public key used to encrypt
-the challenge.&nbsp; This will allow</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; -- the client to find the appropriate
-key to do the decryption.</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; challenge&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
-OCTET STRING</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; -- the encryption (under the public
-key for which the cert.</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; -- request is being made) of Rand,
-where Rand is specified as</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; --&nbsp;&nbsp; Rand ::= SEQUENCE
-{</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; --&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
-int&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; INTEGER,</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; --&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
-- the randomly-generated INTEGER A (above)</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; --&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
-senderHash&nbsp; OCTET STRING</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; --&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
-- the result of applying the one-way function (owf) to</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; --&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
-- the sender's general name</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; --&nbsp;&nbsp; }</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; -- the size of "int" must be small
-enough such that "Rand" can be</tt>
-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; -- contained within a single PKCS
-#1 encryption block.</tt>
-<br><tt>&nbsp; }</tt>
-<p>&copy; Copyright 1999 Netscape Communications Corporation
-</body>
-</html>

mozilla/security/psm/doc/contents.htm

@@ -1,171 +0,0 @@
-<html><head>
-<title></title>
-
-</HEAD>
-
-
-<FONT FACE="arial, helvetica, sans-serif"  size="-1">
-<a name="TOP">
-<IMG SRC="cartbanner.gif" WIDTH="432" HEIGHT="36" HSPACE="0" VSPACE="0">
-<table bgcolor="#cccccc" width="100%">
-<tr><td><IMG SRC="w.gif" WIDTH=1 HEIGHT=3 BORDER=0></td></tr>
-</table>
-<BR><BR>
-
-
-
-<TABLE CELLPADDING=5 CELLSPACING=2 border=0>
-<TR>
-
-<TD> <a href="help.htm">Next<IMG SRC="next.gif" WIDTH=16 
-
-HEIGHT=14 ALIGN="texttop" BORDER=0></a></FONT></TD>   
-<TD BGCOLOR="#FFFFFF"><a href="contents.htm">Topics</a></FONT></TD>
-
-
-</TR>
-</TABLE>
-</TD></TR> 
-</TABLE>
-
-<BR> <BR>
-
-</a>
-</DIV>
-
-</P>
-<h1>Contents</h1>
-
-<B><a href="help.htm#1024926"> 	
-</B> </A> <p>
-<p><b>
-<a href="help.htm#1057187">
- Introduction to Personal Security Manager 	
-</a></b><br><DD>
-
-<a href="help.htm#1044573">
- About Personal Security Manager Help 	
-</a><br><DD>
-
-<a href="help.htm#1043598">
- What You Can Do with Personal Security Manager 	
-</a><br><DD>
-
-<a href="help.htm#1026014">
- Understanding Network Security 	
-</a><br>
-<p><b>
-<a href="help.htm#1045279">
- Information Tab 	
-</a></b><br><DD>
-
-<a href="help.htm#1041627">
- Information About Web Pages 	
-</a><br><DD>
-
-<a href="help.htm#1046060">
- Information About Stored Email Messages 	
-</a><br><DD>
-
-<a href="help.htm#1046671">
- Information About Email Messages You Are Composing 	
-</a><br>
-<p><b>
-<a href="help.htm#1030083">
- Applications Tab 	
-</a></b><br><DD>
-
-<a href="help.htm#1030967">
- Navigator 	
-</a><br><DD>
-
-<a href="help.htm#1031452">
- Messenger 	
-</a><br><DD>
-
-<a href="help.htm#1031152">
- Java/JavaScript 	
-</a><br>
-<p><b>
-<a href="help.htm#1030743">
- Certificates Tab 	
-</a></b><br><DD>
-
-<a href="help.htm#1047547">
- Certificates&#151;Mine 	
-</a><br><DD>
-
-<a href="help.htm#1031428">
- Certificates&#151;Others 	
-</a><br><DD>
-
-<a href="help.htm#1031432">
- Certificates&#151;Web Sites 	
-</a><br><DD>
-
-<a href="help.htm#1031434">
- Certificates&#151;Authorities 	
-</a><br>
-<p><b>
-<a href="help.htm#1036138">
- Advanced Tab 	
-</a></b><br><DD>
-
-<a href="help.htm#1036162">
- Modules 	
-</a><br><DD>
-
-<a href="help.htm#1036164">
- Options 	
-</a><br>
-<p><b>
-<a href="help.htm#1056728">
- Other Personal Security Manager Windows 	
-</a></b><br><DD>
-
-<a href="help.htm#1055385">
- Certificate Information 	
-</a><br><DD>
-
-<a href="help.htm#1035650">
- Choose Security Device 	
-</a><br><DD>
-
-<a href="help.htm#1041171">
- Enrollment Information 	
-</a><br><DD>
-
-<a href="help.htm#1055232">
- Certificate Renewal 	
-</a><br><DD>
-
-<a href="help.htm#1041200">
- Choosing a Certificate 	
-</a><br><DD>
-
-<a href="help.htm#1036401">
- New Certificate Authority 	
-</a><br><DD>
-
-<a href="help.htm#1041248">
- Web Site Certificates 	
-</a><br><DD>
-
-<a href="help.htm#1036488">
- Request for Signature 	
-</a><br><FONT FACE="sans-Serif" SIZE=+1>&nbsp;<BR>
-<a href="glossary.htm#996904">
-Glossary 	
-</a>
-</A> </FONT>
-
-<BR><BR><BR>
-
-&copy; Copyright 2000 Netscape Communications Corporation
-</FONT> </CENTER>
-
-<BR>
-
-</BODY>
-
-</HTML>

mozilla/security/psm/doc/glossary.htm

@@ -1,417 +0,0 @@
-<html><head>
-<title></title>
-
-<script languag=javascript> 
-
-  <!-- 
-  if (typeof(crypto.disableRightClick) == "function") { 
-      crypto.disableRightClick(); 
-  } 
-  // --> 
-
-</script>
-</HEAD>
-
-<FONT FACE="arial, helvetica, sans-serif" size="-1">
-<a name="TOP">
-
-<IMG SRC="cartbanner.gif" WIDTH="432" HEIGHT="36" HSPACE="0" VSPACE="0">
-<table bgcolor="#cccccc" width="100%">
-<tr><td><IMG SRC="w.gif" WIDTH=1 HEIGHT=3 BORDER=0></td></tr>
-</table>
-
-<BR><BR>
-<TABLE CELLPADDING=5 CELLSPACING=2 border=0>
-<TR><TD BGCOLOR="#FFFFFF"><a href="help.htm"><IMG SRC="prev.gif" WIDTH=16 
-
-HEIGHT=14 ALIGN="texttop" BORDER=0>Previous</a>
-  </TD>
-
- 
-<TD BGCOLOR="#FFFFFF"><a href="contents.htm">Topics</a></TD>
-
-
-</TR>
-</TABLE>
-
-<BR> <BR>
-
-</a>
-</DIV>
-
-</P>
-<h1><A NAME="
-"></A><A NAME="996904">
-Glossary 
-</A></h1><dl>
-<A NAME="authentication"></A><A NAME="998782">
-<B>authentication.</B>&nbsp;
-</A><A NAME="1013907">
-Assurance that a party to a computerized transaction is not an impostor. Authentication typically involves the use of a password, certificate, personal identification number (PIN), or other information that can be used to validate identity over a computer network. See also <a href="glossary.htm#1014123">password-based authentication</a>, <a href="glossary.htm#1018581">certificate-based authentication</a>, <a href="glossary.htm#1021054">client authentication</a>, <a href="glossary.htm#1031070">server authentication</a>.<P>
-</A>
-<A NAME="CA"></A><A NAME="1021395">
-<B>CA.</B>&nbsp;
-</A><A NAME="1021418">
-See <a href="glossary.htm#1020903"></a><a href="glossary.htm#1020903">certificate authority (CA)</a>.<P>
-</A>
-<A NAME="CA certificate"></A><A NAME="1017503">
-<B>CA certificate.</B>&nbsp;
-</A><A NAME="1017507">
-A certificate that identifies a certificate authority. See also <a href="glossary.htm#1020903">certificate authority (CA)</a>, <a href="glossary.htm#999541">subordinate CA</a>, <a href="glossary.htm#1015631">root CA</a>.<P>
-</A>
-<A NAME="certificate"></A><A NAME="1018895">
-<B>certificate.</B>&nbsp;
-</A><A NAME="1018896">
-The digital equivalent of an ID card. A certificate specifies the name of an individual, company, or other entity and certifies that a public key, which is included in the certificate, belongs to that entity. When you digitally sign a message or other data, the digital signature for that message is created with the aid of the private key that corresponds to the public key in your certificate. A certificate is issued and digitally signed by a <a href="glossary.htm#1020903">certificate authority (CA)</a>. A certificate's validity can be verified by checking the CA's <a href="glossary.htm#1013995">digital signature</a>. Also called digital ID, digital passport, public-key certificate X.509 certificate, and security certificate. See also <a href="glossary.htm#1019178">public-key cryptography</a>.<P>
-</A>
-<A NAME="certificate authority (CA)"></A><A NAME="1020903">
-<B>certificate authority (CA).</B>&nbsp;
-</A><A NAME="1020904">
-A service that issues a certificate after verifying the identity of the person or entity the certificate is intended to identify. A CA also renews and revokes certificates and generates a list of revoked certificates at regular intervals. CAs can be independent vendors (such as the CAs listed at <a href= "https://certs.netscape.com/client.html" TARGET="_blank">Certificate Authority Services</a>) or a person or organization using certificate-issuing server software (such as Netscape Certificate Management System). See also <a href="glossary.htm#1018895">certificate</a>, <a href="glossary.htm#1019940">certificate revocation list (CRL)</a>.<P>
-</A>
-<A NAME="certificate-based authentication"></A><A NAME="1018581">
-<B>certificate-based authentication.</B>&nbsp;
-</A><A NAME="1018582">
-Verification of identity based on certificates and public-key cryptography. See also <a href="glossary.htm#1014123">password-based authentication</a>.<P>
-</A>
-<A NAME="certificate chain"></A><A NAME="1018500">
-<B>certificate chain.</B>&nbsp;
-</A><A NAME="1019929">
-A hierarchical series of certificates signed by successive certificate authorities. A CA certificate identifies a <a href="glossary.htm#1020903">certificate authority (CA)</a> and is used to sign certificates issued by that authority. A CA certificate can in turn be signed by the CA certificate of a parent CA and so on up to a <a href="glossary.htm#1015631">root CA</a>. <P>
-</A>
-<A NAME="certificate fingerprint"></A><A NAME="1020297">
-<B>certificate fingerprint.</B>&nbsp;
-</A><A NAME="1020326">
-A unique number associated with a certificate. The number is not part of the certificate itself but is produced by applying a mathematical function to the contents of the certificate. If the contents of the certificate change, even by a single character, the function produces a different number. Certificate fingerprints can therefore be used to verify that certificates have not been tampered with.<P>
-</A>
-<A NAME="certificate renewal"></A><A NAME="1031319">
-<B>certificate renewal.</B>&nbsp;
-</A><A NAME="1031323">
-The process of renewing a <a href="glossary.htm#1018895">certificate</a> that is about to expire.<P>
-</A>
-<A NAME="certificate revocation list (CRL)"></A><A NAME="1019940">
-<B>certificate revocation list (CRL).</B>&nbsp;
-</A><A NAME="1021047">
-A list of revoked certificates that is generated and signed by a <a href="glossary.htm#1020903">certificate authority (CA)</a>. You can download the latest CRL to your browser or to a server, then check against it to make sure that certificates are still valid before permitting their use for authentication. <P>
-</A>
-<A NAME="certificate store"></A><A NAME="1023462">
-<B>certificate store.</B>&nbsp;
-</A><A NAME="1032978">
-The collection of certificates, or electronic IDs, maintained by Personal Security Manager on your behalf. These include your own certificates stored on one or more security devices, other people's certificates, web site certificates, and <a href="glossary.htm#1020903"></a>CA certificates. See also <a href="glossary.htm#1020903">certificate authority (CA)</a>, <a href="glossary.htm#1018895">certificate</a>, <a href="glossary.htm#1028962">security device</a>.<P>
-</A>
-<A NAME="certificate verification"></A><A NAME="1025527">
-<B>certificate verification.</B>&nbsp;
-</A><A NAME="1025531">
-When Personal Security Manager verifies a certificate, it confirms that the digital signature was created by a CA whose own CA certificate is both present in the certificate store and marked as trusted for issuing that kind of certificate. It also confirms that the certificate being verified has not been marked as untrusted in the certificate store. Finally, if the <a href="glossary.htm#1029304">Online Certificate Status Protocol (OCSP)</a> has been activated (from the Options panel under the Advanced tab), Personal Security Manager also performs an on-line check. It does so by looking up the certificate in a list of valid certificates maintained at a URL that is specified either in the certificate itself or in the OCSP Settings window. If any of these checks fail, Personal Security Manager marks the certificate as unverified and won't recognize the identity it certifies.<P>
-</A>
-<A NAME="cipher"></A><A NAME="1021048">
-<B>cipher.</B>&nbsp;
-</A><A NAME="1021052">
-See <a href="glossary.htm#1019976">cryptographic algorithm</a>.<P>
-</A>
-<A NAME="client"></A><A NAME="1029510">
-<B>client.</B>&nbsp;
-</A><A NAME="1029547">
-Software (such as browser software) that sends requests to and receives information from a <a href="glossary.htm#1029749">server</a>, which is usually running on a different computer. A computer on which client software runs is also described as a client.<P>
-</A>
-<A NAME="client authentication"></A><A NAME="1021054">
-<B>client authentication.</B>&nbsp;
-</A><A NAME="1014557">
-The process of identifying a <a href="glossary.htm#1029510">client</a> to a <a href="glossary.htm#1029749">server</a>, for example with a name and password or with a <a href="glossary.htm#1014561">client SSL certificate</a> and some digitally signed data. See also <a href="glossary.htm#999463">Secure Sockets Layer (SSL)</a>, <a href="glossary.htm#1031070">server authentication</a>.<P>
-</A>
-<A NAME="client SSL certificate"></A><A NAME="1014561">
-<B>client SSL certificate.</B>&nbsp;
-</A><A NAME="1014562">
-A certificate that a <a href="glossary.htm#1029510">client</a> (for example, browser software such as Netscape Communicator) presents to a <a href="glossary.htm#1029749">server</a> to authenticate the identity of the client (or the identity of the person using the client) using the <a href="glossary.htm#999463">Secure Sockets Layer (SSL)</a> protocol. See also <a href="glossary.htm#1021054">client authentication</a>.<P>
-</A>
-<A NAME="cryptographic algorithm"></A><A NAME="1019976">
-<B>cryptographic algorithm.</B>&nbsp;
-</A><A NAME="1019985">
-A set of rules or directions used to perform cryptographic operations such as <a href="glossary.htm#999078">encryption</a> and <a href="glossary.htm#998999">decryption</a>. Sometimes called a <I>cipher.</I><P>
-</A>
-<A NAME="cryptography"></A><A NAME="1026002">
-<B>cryptography.</B>&nbsp;
-</A><A NAME="1026018">
-The art and practice of scrambling (encrypting) and unscrambling (decrypting) information. For example, cryptographic techniques are used to scramble an unscramble information flowing between commercial web sites and your browser. See also <a href="glossary.htm#1019178">public-key cryptography</a>.<P>
-</A>
-<A NAME="decryption"></A><A NAME="998999">
-<B>decryption.</B>&nbsp;
-</A><A NAME="999005">
-The process of unscrambling data that has been encrypted. See also <a href="glossary.htm#999078">encryption</a>.<P>
-</A>
-<A NAME="digital ID"></A><A NAME="999011">
-<B>digital ID.</B>&nbsp;
-</A><A NAME="999017">
-See <a href="glossary.htm#1018895">certificate</a>.<P>
-</A>
-<A NAME="digital signature"></A><A NAME="1013995">
-<B>digital signature.</B>&nbsp;
-</A><A NAME="1013996">
-A code created from both the data to be signed and the private key of the signer. This code is unique for each new piece of data. Even a single comma added to a message changes the digital signature for that message. Successful validation of your digital signature by appropriate software not only provides evidence that you approved the transaction or message, but also provides evidence that the data has not changed since you digitally signed it. A digital signature has nothing to do with a handwritten signature, although it can sometimes be used for similar legal purposes. See also <a href="glossary.htm#999248">nonrepudiation</a>, <a href="glossary.htm#999618">tamper detection</a>.<P>
-</A>
-<A NAME="distinguished name (DN)"></A><A NAME="1022191">
-<B>distinguished name (DN).</B>&nbsp;
-</A><A NAME="1022194">
-A specially formatted name that uniquely identifies the subject of a certificate.<P>
-</A>
-<A NAME="dual key pairs"></A><A NAME="1020489">
-<B>dual key pairs.</B>&nbsp;
-</A><A NAME="1020619">
-Two public-private key pairs--four keys altogether--corresponding to two separate certificates. The private key of one pair is used for signing operations, and the public and private keys of the other pair are used for encryption and decryption operations. Each pair corresponds to a separate <a href="glossary.htm#1018895">certificate</a>. See also <a href="glossary.htm#1019178">public-key cryptography</a>.<P>
-</A>
-<A NAME="eavesdropping"></A><A NAME="1020620">
-<B>eavesdropping.</B>&nbsp;
-</A><A NAME="1013975">
-Surreptitious interception of information sent over a network by an entity for which the information is not intended.<P>
-</A>
-<A NAME="encryption"></A><A NAME="999078">
-<B>encryption.</B>&nbsp;
-</A><A NAME="1024038">
-The process of scrambling information in a way that disguises its meaning. For example, encrypted connections between computers make it very difficult for third-parties to unscramble, or <I>decrypt,</I> information flowing over the connection. Encrypted information can be decrypted only by someone who possesses the appropriate key. See also <a href="glossary.htm#1019178">public-key cryptography</a>.<P>
-</A>
-<A NAME="encryption certificate"></A><A NAME="1024953">
-<B>encryption certificate.</B>&nbsp;
-</A><A NAME="1024978">
-A certificate whose public key corresponds to a private key used for encryption only. Encryption certificates are not used for signing operations. See also <a href="glossary.htm#1020489">dual key pairs</a>, <a href="glossary.htm#999493">signing certificate</a>.<P>
-</A>
-<A NAME="encryption key"></A><A NAME="1021254">
-<B>encryption key.</B>&nbsp;
-</A><A NAME="1021255">
-A private key used for encryption only. An encryption key and its equivalent public key, plus a <a href="glossary.htm#1021282">signing key</a> and its equivalent public key, constitute a <a href="glossary.htm#1020489">dual key pairs</a>.<P>
-</A>
-<A NAME="fingerprint"></A><A NAME="1020434">
-<B>fingerprint.</B>&nbsp;
-</A><A NAME="1020450">
-See <a href="glossary.htm#1020297">certificate fingerprint</a>.<P>
-</A>
-<A NAME="FIPS PUBS 140-1"></A><A NAME="1025742">
-<B>FIPS PUBS 140-1.</B>&nbsp;
-</A><A NAME="1025743">
-Federal Information Processing Standards Publications (FIPS PUBS) 140-1 is a US government standard for implementations of cryptographic modules--that is, hardware or software that encrypts and decrypts data or performs other cryptographic operations (such as creating or verifying digital signatures). Many products sold to the US government must comply with one or more of the FIPS standards.<P>
-</A>
-<A NAME="key"></A><A NAME="999203">
-<B>key.</B>&nbsp;
-</A><A NAME="999212">
-A large number used by a <a href="glossary.htm#1019976">cryptographic algorithm</a> to encrypt or decrypt data. A person's public key, for example, allows other people to encrypt messages to that person. The encrypted messages must be decrypted with the corresponding private key. See also <a href="glossary.htm#1019178">public-key cryptography</a>.<P>
-</A>
-<A NAME="Lightweight Directory Access Protocol (LDAP)"></A><A NAME="1022286">
-<B>Lightweight Directory Access Protocol (LDAP).</B>&nbsp;
-</A><A NAME="1022287">
-A protocol for accessing directory services across multiple platforms. LDAP is a simplified version of Directory Access Protocol (DAP), used to access X.500 directories. <P>
-</A>
-<A NAME="master key"></A><A NAME="1032598">
-<B>master key.</B>&nbsp;
-</A><A NAME="1032639">
-A symmetric key used by Personal Security Manager to encrypt information on behalf of other applications. For example, Netscape 6 uses Personal Security Manager and your master key to encrypt email passwords, web site passwords, and other stored sensitive information. See also <a href="glossary.htm#999604">symmetric encryption</a>.<P>
-</A>
-<A NAME="misrepresentation"></A><A NAME="1014057">
-<B>misrepresentation.</B>&nbsp;
-</A><A NAME="1014058">
-Presentation of an entity as a person or organization that it is not. For example, a web site might pretend to be a furniture store when it is really just a site that takes credit card payments but never sends any goods. See also <a href="glossary.htm#1014366">spoofing</a>.<P>
-</A>
-<A NAME="Netscape Certificate Management System"></A><A NAME="1018306">
-<B>Netscape Certificate Management System.</B>&nbsp;
-</A><A NAME="1018308">
-A highly configurable set of software components and tools for creating, deploying, and managing certificates. You enroll with the system to obtain certificates of all kinds; the system maintains information about the certificates it issues.<P>
-</A>
-<A NAME="nonrepudiation"></A><A NAME="999248">
-<B>nonrepudiation.</B>&nbsp;
-</A><A NAME="999254">
-The inability, of the sender of a message, to deny having sent the message. A regular hand-written signature provides one form of nonrepudiation. A <a href="glossary.htm#1013995">digital signature</a> provides another.<P>
-</A>
-<A NAME="object signing"></A><A NAME="1014095">
-<B>object signing.</B>&nbsp;
-</A><A NAME="1014096">
-A technology that allows software developers to sign Java code, JavaScript scripts, or any kind of file, and that allows users to identify the signers and control access by signed code to local system resources.<P>
-</A>
-<A NAME="object-signing certificate"></A><A NAME="1014097">
-<B>object-signing certificate.</B>&nbsp;
-</A><A NAME="1014098">
-A certificate whose corresponding private key is used to sign objects such as code files. See also <a href="glossary.htm#1014095">object signing</a>.<P>
-</A>
-<A NAME="Online Certificate Status Protocol (OCSP)"></A><A NAME="1029304">
-<B>Online Certificate Status Protocol (OCSP).</B>&nbsp;
-</A><A NAME="1029312">
-A set of rules that Personal Security Manager follows to perform an online check of an email certificate's validity each time the certificate is used. This process involves checking the certificate against a list of valid certificates maintained at a specified web site. Your computer must be online for OCSP to work.<P>
-</A>
-<A NAME="password-based authentication"></A><A NAME="1014123">
-<B>password-based authentication.</B>&nbsp;
-</A><A NAME="1014124">
-Confident identification by means of a name and password. See also <a href="glossary.htm#998782">authentication</a>.<P>
-</A>
-<A NAME="Personal Security Password"></A><A NAME="1032744">
-<B>Personal Security Password.</B>&nbsp;
-</A><A NAME="1032748">
-A password used by Personal Security Manager to protect the master key and/or private keys stored on a <a href="glossary.htm#1028962">security device</a>. Personal Security Manager needs to access your private keys, for example, when you sign email messages or use one of your own certificates to identify yourself to a web site. It needs to access your master key when it encrypts or decrypts information on behalf of another application&#151;for example, when Netscape 6 needs to store or access your email password. You can set or change your personal security password from the Certificates tab in Personal Security Manager. Each security device requires a separate Personal Security Password. See also <a href="glossary.htm#1015387">private key</a>, <a href="glossary.htm#1032598">master key</a>.<P>
-</A>
-<A NAME="PKCS #11"></A><A NAME="1025194">
-<B>PKCS #11.</B>&nbsp;
-</A><A NAME="1025195">
-The public-key cryptography standard that governs security devices such as smart cards. See also <a href="glossary.htm#1028962">security device</a>, <a href="glossary.htm#1027625">smart card</a>.<P>
-</A>
-<A NAME="PKCS #11 module"></A><A NAME="1025197">
-<B>PKCS #11 module.</B>&nbsp;
-</A><A NAME="1025271">
-A program on your computer that manages cryptographic services such as encryption and decryption using the PKCS #11 standard. PKCS #11 modules (also called <I>cryptographic modules</I>, <I>cryptographic service providers,</I> or <I>security modules</I>) can be thought of as drivers for cryptographic devices that can be implemented in either hardware or software. A PKCS #11 module always controls one or more slots<B>,</B> which may be implemented as physical hardware slots in some form of physical reader (for example, for smart cards) or as conceptual slots in software. Each slot for a PKCS #11 module can in turn contain a <a href="glossary.htm#1028962">security device</a> (also called <I>token</I>)<B>,</B> which is the hardware or software device that actually provides cryptographic services and optionally stores certificates and keys. Personal Security Manager provides a built-in PKCS #11 module. You may install additional modules on your computer to control smart card readers or other hardware devices.<P>
-</A>
-<A NAME="portable security password"></A><A NAME="1024655">
-<B>portable security password.</B>&nbsp;
-</A><A NAME="1024670">
-A password that protects a certificate that you are backing up or have previously backed up. Personal Security Manager asks you to set this password when you back up a certificate, and requests it when you attempt to restore a certificate that has previously been backed up. <P>
-</A>
-<A NAME="private key"></A><A NAME="1015387">
-<B>private key.</B>&nbsp;
-</A><A NAME="1015391">
-One of a pair of keys used in public-key cryptography. The private key is kept secret and is used to decrypt data that has been encrypted with the corresponding public key.<P>
-</A>
-<A NAME="PSM Private Keys security device"></A><A NAME="1032045">
-<B>PSM Private Keys security device.</B>&nbsp;
-</A><A NAME="1032110">
-The default <a href="glossary.htm#1028962">security device</a> used by Personal Security Manager to store private keys associated with your certificates. In addition to private keys, the PSM Private Keys security device stores the master key used by Netscape 6 to encrypt email passwords, web site passwords, and other sensitive information. See also <a href="glossary.htm#1015387">private key</a>, <a href="glossary.htm#1032598">master key</a>.<P>
-</A>
-<A NAME="public key"></A><A NAME="1019172">
-<B>public key.</B>&nbsp;
-</A><A NAME="1019173">
-One of a pair of keys used in public-key cryptography. The public key is distributed freely and published as part of a <a href="glossary.htm#1018895">certificate</a>. It is typically used to encrypt data sent to the public key's owner, who then decrypts the data with the corresponding private key.<P>
-</A>
-<A NAME="public-key cryptography"></A><A NAME="1019178">
-<B>public-key cryptography.</B>&nbsp;
-</A><A NAME="1023765">
-A set of well-established techniques and standards that allow an entity (such as a person, an organization, or hardware such as a router) to verify its identity electronically or to sign and encrypt electronic data. Two keys are involved: a <a href="glossary.htm#1019172">public key</a> and a <a href="glossary.htm#1015387">private key</a>. The public key is published as part of a <a href="glossary.htm#1018895">certificate</a>, which associates that key with a particular identity. The corresponding private key is kept secret. Data encrypted with the public key can be decrypted only with the private key. <P>
-</A>
-<A NAME="public-key infrastructure (PKI)"></A><A NAME="999412">
-<B>public-key infrastructure (PKI).</B>&nbsp;
-</A><A NAME="1014263">
-The standards and services that facilitate the use of public-key cryptography and certificates in a networked environment.<P>
-</A>
-<A NAME="root CA"></A><A NAME="1015631">
-<B>root CA.</B>&nbsp;
-</A><A NAME="1015635">
-The <a href="glossary.htm#1020903">certificate authority (CA)</a> with a self-signed certificate at the top of a <a href="glossary.htm#1018500">certificate chain</a>. See also <a href="glossary.htm#999541">subordinate CA</a>.<P>
-</A>
-<A NAME="Secure Sockets Layer (SSL)"></A><A NAME="999463">
-<B>Secure Sockets Layer (SSL).</B>&nbsp;
-</A><A NAME="999472">
-A protocol that allows mutual authentication between a <a href="glossary.htm#1029510">client</a> and a <a href="glossary.htm#1029749">server</a> for the purpose of establishing an authenticated and encrypted connection. SSL runs above TCP/IP and below HTTP, LDAP, IMAP, NNTP, and other high-level network protocols. The new Internet Engineering Task Force (IETF) standard called Transport Layer Security (TLS) is based on SSL. See also <a href="glossary.htm#998782">authentication</a>, <a href="glossary.htm#999078">encryption</a>.<P>
-</A>
-<A NAME="security certificate"></A><A NAME="1028900">
-<B>security certificate.</B>&nbsp;
-</A><A NAME="1028904">
-See <a href="glossary.htm#1018895">certificate</a>.<P>
-</A>
-<A NAME="security device"></A><A NAME="1028962">
-<B>security device.</B>&nbsp;
-</A><A NAME="1028963">
-A hardware or software device that provides cryptographic services such as encryption and decryption and can store certificates and keys. A smart card is one example of a hardware security device. Personal Security Manager contains its own internal security device, called the <a href="glossary.htm#1032045">PSM Private Keys security device</a>, that is implemented in software. Each security device is protected by its own <a href="glossary.htm#1032744">Personal Security Password</a>.<P>
-</A>
-<A NAME="security module"></A><A NAME="1029083">
-<B>security module.</B>&nbsp;
-</A><A NAME="1029097">
-See <a href="glossary.htm#1025197">PKCS #11 module</a>.<P>
-</A>
-<A NAME="security token"></A><A NAME="1028905">
-<B>security token.</B>&nbsp;
-</A><A NAME="1028909">
-See <a href="glossary.htm#1028962">security device</a>.<P>
-</A>
-<A NAME="server"></A><A NAME="1029749">
-<B>server.</B>&nbsp;
-</A><A NAME="1029869">
-Software (such as software that serves up web pages) that receives requests from and sends information to a <a href="glossary.htm#1029510">client</a>, which is usually running on a different computer. A computer on which server software runs is also described as a server.<P>
-</A>
-<A NAME="server authentication"></A><A NAME="1031070">
-<B>server authentication.</B>&nbsp;
-</A><A NAME="1031080">
-The process of identifying a <a href="glossary.htm#1029749">server</a> to a <a href="glossary.htm#1029510">client</a> by using a <a href="glossary.htm#1029874">server SSL certificate</a>. See also <a href="glossary.htm#1021054">client authentication</a>, <a href="glossary.htm#999463">Secure Sockets Layer (SSL)</a>.<P>
-</A>
-<A NAME="server SSL certificate"></A><A NAME="1029874">
-<B>server SSL certificate.</B>&nbsp;
-</A><A NAME="999500">
-A certificate that a <a href="glossary.htm#1029749">server</a> presents to a <a href="glossary.htm#1029510">client</a> to authenticate the server's identity using the <a href="glossary.htm#999463">Secure Sockets Layer (SSL)</a> protocol.<P>
-</A>
-<A NAME="signing certificate"></A><A NAME="999493">
-<B>signing certificate.</B>&nbsp;
-</A><A NAME="999507">
-A certificate whose corresponding <a href="glossary.htm#1015387">private key</a> is used to sign transmitted data, so that the receiver can verify the identity of the sender. Certificate authorities (CAs) often issue a signing certificate that will be used to sign email messages at the same time as an <a href="glossary.htm#1024953">encryption certificate</a> that will be used to encrypt email messages. See also <a href="glossary.htm#1020489">dual key pairs</a>, <a href="glossary.htm#1013995">digital signature</a>.<P>
-</A>
-<A NAME="signing key"></A><A NAME="1021282">
-<B>signing key.</B>&nbsp;
-</A><A NAME="1021283">
-A private key used for signing only. A signing key and its equivalent public key, together with an <a href="glossary.htm#1021254">encryption key</a> and its equivalent public key, constitute <a href="glossary.htm#1020489">dual key pairs</a>.<P>
-</A>
-<A NAME="slot"></A><A NAME="1025218">
-<B>slot.</B>&nbsp;
-</A><A NAME="1025222">
-A piece of hardware, or its equivalent in software, that is controlled by a <a href="glossary.htm#1025197">PKCS #11 module</a> and designed to contain a <a href="glossary.htm#1028962">security device</a>. <P>
-</A>
-<A NAME="smart card"></A><A NAME="1027625">
-<B>smart card.</B>&nbsp;
-</A><A NAME="1027626">
-A small device, typically about the size of a credit card, that contains a microprocessor and is capable of storing cryptographic information (such as keys and certificates) and performing cryptographic operations. Smart cards use the <a href="glossary.htm#1025194">PKCS #11</a> standard. A smart card is one kind of <a href="glossary.htm#1028962">security device</a>. <P>
-</A>
-<A NAME="spoofing"></A><A NAME="1014366">
-<B>spoofing.</B>&nbsp;
-</A><A NAME="1014367">
-Pretending to be someone else. For example, a person can pretend to have the email address <FONT FACE="courier, courier new, monospace">jdoe@mozilla.com</FONT>, or a computer can identify itself as a site called <FONT FACE="courier, courier new, monospace">www.mozilla.com</FONT> when it is not. Spoofing is one form of <a href="glossary.htm#1014057">misrepresentation</a>.<P>
-</A>
-<A NAME="SSL"></A><A NAME="999533">
-<B>SSL.</B>&nbsp;
-</A><A NAME="999539">
-See <a href="glossary.htm#999463">Secure Sockets Layer (SSL)</a>. <P>
-</A>
-<A NAME="subject"></A><A NAME="1013880">
-<B>subject.</B>&nbsp;
-</A><A NAME="1013881">
-The entity (such as a person, organization, or router) identified by a <a href="glossary.htm#1018895">certificate</a>. In particular, the subject field of a certificate contains the certified entity's <a href="glossary.htm#1021328">subject name</a> and other characteristics.<P>
-</A>
-<A NAME="subject name"></A><A NAME="1021328">
-<B>subject name.</B>&nbsp;
-</A><A NAME="1021338">
-A <a href="glossary.htm#1022191">distinguished name (DN)</a> that uniquely describes the <a href="glossary.htm#1013880">subject</a> of a <a href="glossary.htm#1018895">certificate</a>.<P>
-</A>
-<A NAME="subordinate CA"></A><A NAME="999541">
-<B>subordinate CA.</B>&nbsp;
-</A><A NAME="999591">
-A <a href="glossary.htm#1020903">certificate authority (CA)</a> whose certificate is signed by another subordinate CA or by the root CA. See also <a href="glossary.htm#1018500">certificate chain</a>, <a href="glossary.htm#1015631">root CA</a>.<P>
-</A>
-<A NAME="symmetric encryption"></A><A NAME="999604">
-<B>symmetric encryption.</B>&nbsp;
-</A><A NAME="999625">
-An encryption method that uses a single cryptographic key to both encrypt and decrypt a given message.<P>
-</A>
-<A NAME="tamper detection"></A><A NAME="999618">
-<B>tamper detection.</B>&nbsp;
-</A><A NAME="999631">
-A mechanism ensuring that data received in electronic form has not been tampered with; that is, that the data received corresponds entirely with the original version of the same data.<P>
-</A>
-<A NAME="TLS"></A><A NAME="1027427">
-<B>TLS.</B>&nbsp;
-</A><A NAME="1027428">
-See <a href="glossary.htm#999463">Secure Sockets Layer (SSL)</a>.<P>
-</A>
-<A NAME="token"></A><A NAME="1024528">
-<B>token.</B>&nbsp;
-</A><A NAME="1024586">
-See <a href="glossary.htm#1028962">security device</a>.<P>
-</A>
-<A NAME="trust"></A><A NAME="1019748">
-<B>trust.</B>&nbsp;
-</A><A NAME="1020186">
-Confident reliance on a person or other entity. In the context of <a href="glossary.htm#999412">public-key infrastructure (PKI)</a>, trust usually refers to the relationship between the user of a certificate and the <a href="glossary.htm#1020903">certificate authority (CA)</a> that issued the certificate. If you use Personal Security Manager to specify that you trust a CA, Personal Security Manager trusts valid certificates issued by that CA unless you specify otherwise in the settings for individual certificates. You use the Authorities panel of the Certificates tab in Personal Security Manager to specify the kinds of certificates you trust or don't trust different CAs to issue. <P>
-</A>
-<A NAME="1028719">
-<B></B><a href="glossary.htm#1028962"></a><P>
-</A>
-</dl>
-
-
-<BR>
-
-&copy; Copyright 2000 Netscape Communications Corporation
-</FONT> </CENTER>
-
-<BR>
-
-</BODY>
-
-</HTML>

mozilla/security/psm/doc/license.txt

@@ -1,343 +0,0 @@
-
-NETSCAPE CLIENT PRODUCTS LICENSE AGREEMENT
-Redistribution Or Rental Not Permitted
-
-These terms apply to Personal Security Manager.
-
-BY CLICKING THE ACCEPTANCE BUTTON OR INSTALLING OR
-USING PERSONAL SECURITY MANAGER SOFTWARE (THE "PRODUCT"), 
-THE INDIVIDUAL OR ENTITY LICENSING THE PRODUCT
-("LICENSEE") IS CONSENTING TO BE BOUND BY AND IS
-BECOMING A PARTY TO THIS AGREEMENT.  IF LICENSEE DOES
-NOT AGREE TO ALL OF THE TERMS OF THIS AGREEMENT, THE
-BUTTON INDICATING NON-ACCEPTANCE MUST BE
-SELECTED, AND LICENSEE MUST NOT INSTALL OR USE
-THE SOFTWARE.
-
-1. LICENSE AGREEMENT.  As used in this Agreement, for
-residents of Europe, the Middle East or Africa,
-"Netscape" shall mean Netscape Communications Ireland
-Limited; for residents of Japan, "Netscape" shall
-mean Netscape Communications (Japan), Ltd.; for
-residents of all other countries, "Netscape" shall
-mean Netscape Communications Corporation.  In this
-Agreement "Licensor" shall mean Netscape except under
-the following circumstances: (i) if Licensee acquired
-the Product as a bundled component of a third party
-product or service, then such third party shall be
-Licensor; and (ii) if any third party software is
-included as part of the default installation and no
-license is presented for acceptance the first time
-that third party software is invoked, then the use of
-that third party software shall be governed by this
-Agreement, but the term "Licensor," with respect to
-such third party software, shall mean the
-manufacturer of that software and not Netscape.  With
-the exception of the situation described in (ii)
-above, the use of any included third party software
-product shall be governed by the third party's
-license agreement and not by this Agreement, whether
-that license agreement is presented for acceptance
-the first time that the third party software is
-invoked, is included in a file in electronic form, or
-is included in the package in printed form.  If more
-than one license agreement was provided for the
-Product, and the terms vary, the order of precedence
-of those license agreements is as follows: a signed
-agreement, a license agreement available for review
-on the Netscape website, a printed or electronic
-agreement that states clearly that it supersedes
-other agreements, a printed agreement provided with
-the Product, an electronic agreement provided with
-the Product.
-
-2. LICENSE GRANT.  Licensor grants Licensee a
-non-exclusive and non-transferable license to
-reproduce and use for personal or internal business
-purposes the executable code version of the Product,
-provided any copy must contain all of the original
-proprietary notices.  This license does not entitle
-Licensee to receive from Netscape hard-copy
-documentation, technical support, telephone
-assistance, or enhancements or updates to the
-Product.  Licensee may not customize the Product
-unless Licensee has also licensed the Netscape
-Client Customization Kit ("CCK"), and then only to
-the extent permitted in the license agreement for CCK,
-as applicable.  Licensee may not redistribute the
-Product unless Licensee has separately entered into a
-distribution agreement with Netscape such as the
-Unlimited Distribution Program Agreement.
-
-3. RESTRICTIONS.  Except as otherwise expressly
-permitted in this Agreement, or in another Netscape
-agreement to which Licensee is a party such as the
-CCK license agreement or a distribution agreement,
-Licensee may not: (i) modify or create any derivative
-works of the Product or documentation, including translation
-or localization; (ii) decompile, disassemble, reverse engineer,
-or otherwise attempt to derive the source code for the
-Product (except to the extent applicable laws
-specifically prohibit such restriction or as provided by the
-Netscape Public License or Mozilla Public License
-for portions of the product governed by those licenses);
-(iii) redistribute, encumber, sell, rent, lease,
-sublicense, or otherwise transfer rights to the
-Product; (iv) remove or alter any trademark, logo,
-copyright or other proprietary notices, legends,
-symbols or labels in the Product; or (v) publish any
-results of benchmark tests run on the Product to a
-third party without Netscape's prior written
-consent.
-
-4. FEES.  There is no license fee for the Product.
-If Licensee wishes to receive the Product on media,
-there may be a small charge for the media and for
-shipping and handling.  Licensee is responsible for
-any and all taxes.
-
-5. TERMINATION.  Without prejudice to any other
-rights, Licensor may terminate this Agreement if
-Licensee breaches any of its terms and conditions.
-Upon termination, Licensee shall destroy all copies
-of the Product.
-
-6. PROPRIETARY RIGHTS.  Title, ownership rights, and
-intellectual property rights in the Product shall
-remain in Netscape and/or its suppliers.  Licensee
-acknowledges such ownership and intellectual property
-rights and will not take any action to jeopardize,
-limit or interfere in any manner with Netscape's or
-its suppliers' ownership of or rights with respect to
-the Product.  The Product is protected by copyright
-and other intellectual property laws and by
-international treaties.  Title and related rights in
-the content accessed through the Product is the
-property of the applicable content owner and is
-protected by applicable law.  The license granted
-under this Agreement gives Licensee no rights to such
-content.
-
-7. USE AND AVAILABILITY OF OPEN SOURCE
-CODE. Portions of Personal Security Manager were created using source
-code governed by the Netscape Public License (NPL) and
-the Mozilla Public License (MPL).  The source code for
-the portions of Personal Security Manager governed by the NPL and MPL
-is available from http://www.mozilla.org under those licenses.
-
-8. DISCLAIMER OF WARRANTY.  THE PRODUCT IS PROVIDED
-FREE OF CHARGE, AND, THEREFORE, ON AN "AS IS" BASIS,
-WITHOUT WARRANTY OF ANY KIND, INCLUDING WITHOUT
-LIMITATION THE WARRANTIES THAT IT IS FREE OF DEFECTS,
-MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR
-NON-INFRINGING.  THE ENTIRE RISK AS TO THE QUALITY
-AND PERFORMANCE OF THE PRODUCT IS BORNE BY LICENSEE.
-SHOULD THE PRODUCT PROVE DEFECTIVE IN ANY RESPECT,
-LICENSEE AND NOT LICENSOR OR ITS SUPPLIERS OR
-RESELLERS OR ANY CONTRIBUTORS TO THE SOURCE CODE
-OF THE PORTIONS OF PERSONAL SECURITY MANAGER AVAILABLE FROM
-HTTP://WWW.MOZILLA.ORG ASSUMES THE ENTIRE COST
-OF ANY SERVICE AND REPAIR.  IN ADDITION, THE SECURITY
-MECHANISMS IMPLEMENTED BY THE PRODUCT HAVE
-INHERENT LIMITATIONS, AND LICENSEE MUST DETERMINE
-THAT THE PRODUCT SUFFICIENTLY MEETS ITS REQUIREMENTS.
-THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
-PART OF THIS AGREEMENT.  NO USE OF THE PRODUCT IS
-AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.
-
-9. LIMITATION OF LIABILITY.  TO THE MAXIMUM EXTENT
-PERMITTED BY APPLICABLE LAW, IN NO EVENT WILL
-LICENSOR OR ITS SUPPLIERS OR RESELLERS OR ANY
-CONTRIBUTORS TO THE SOURCE CODE OF THE PORTIONS OF 
-PERSONAL SECURITY MANAGER AVAILABLE FROM
-HTTP://WWW.MOZILLA.ORG BE LIABLE FOR
-ANY INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL
-DAMAGES ARISING OUT OF THE USE OF OR INABILITY TO USE
-THE PRODUCT, INCLUDING, WITHOUT LIMITATION, DAMAGES
-FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE
-OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL
-DAMAGES OR LOSSES, EVEN IF ADVISED OF THE POSSIBILITY
-THEREOF, AND REGARDLESS OF THE LEGAL OR EQUITABLE
-THEORY (CONTRACT, TORT OR OTHERWISE) UPON WHICH THE
-CLAIM IS BASED.  IN ANY CASE, LICENSOR'S ENTIRE
-LIABILITY UNDER ANY PROVISION OF THIS AGREEMENT SHALL
-NOT EXCEED IN THE AGGREGATE THE SUM OF THE FEES
-LICENSEE PAID FOR THIS LICENSE (IF ANY) AND FEES FOR
-SUPPORT OF THE PRODUCT RECEIVED BY NETSCAPE UNDER A
-SEPARATE SUPPORT AGREEMENT (IF ANY), WITH THE
-EXCEPTION OF DEATH OR PERSONAL INJURY CAUSED BY THE
-NEGLIGENCE OF LICENSOR TO THE EXTENT APPLICABLE LAW
-PROHIBITS THE LIMITATION OF DAMAGES IN SUCH CASES.
-SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR
-LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO
-THIS EXCLUSION AND LIMITATION MAY NOT BE APPLICABLE.
-NETSCAPE IS NOT RESPONSIBLE FOR ANY LIABILITY ARISING
-OUT OF CONTENT PROVIDED BY LICENSEE OR A THIRD PARTY
-THAT IS ACCESSED THROUGH THE PRODUCT AND/OR ANY
-MATERIAL LINKED THROUGH SUCH CONTENT.
-
-10. ENCRYPTION.  If Licensee wishes to use the
-cryptographic features of the Product, then Licensee
-may need to obtain and install a signed digital
-certificate from a certificate authority or a
-certificate server.  Licensee may be charged
-additional fees for certification services.  Licensee
-is responsible for maintaining the security of the
-environment in which the Product is used and the
-integrity of the private key file used with the
-Product.  In addition, the use of digital
-certificates is subject to the terms specified by the
-certificate provider, and there are inherent
-limitations in the capabilities of digital
-certificates.  If Licensee is sending or receiving
-digital certificates, Licensee is responsible for
-familiarizing itself with and evaluating such terms
-and limitations.  If the Product is a version with
-FORTEZZA, Licensee will need to obtain PC Card
-Readers and FORTEZZA Crypto Cards from another vendor
-to enable the FORTEZZA features.
-
-11. EXPORT CONTROL.  Licensee agrees to comply with
-all export laws and restrictions and regulations of
-the United States or foreign agencies or authorities,
-and not to export or re-export the Product or any
-direct product thereof in violation of any such
-restrictions, laws or regulations, or without all
-necessary approvals.  As applicable, each party shall
-obtain and bear all expenses relating to any
-necessary licenses and/or exemptions with respect to
-its own export of the Product from the U.S.  Neither
-the Product nor the underlying information or
-technology may be downloaded or otherwise exported or
-re-exported (i) into Cuba, Iran, Iraq, Libya, North
-Korea, Sudan, Syria or any other country subject to
-U.S. trade sanctions covering the Product, to
-individuals or entities controlled by such countries,
-or to nationals or residents of such countries other
-than nationals who are lawfully admitted permanent
-residents of countries not subject to such sanctions;
-or (ii) to anyone on the U.S. Treasury Department's
-list of Specially Designated Nationals and Blocked
-Persons or the U.S. Commerce Department's Table of
-Denial Orders.  By downloading or using the Product,
-Licensee agrees to the foregoing and represents and
-warrants that it complies with these conditions.
-
-12. HIGH RISK ACTIVITIES.  The Product is not
-fault-tolerant and is not designed, manufactured or
-intended for use or resale as on-line control
-equipment in hazardous environments requiring
-fail-safe performance, such as in the operation of
-nuclear facilities, aircraft navigation or
-communication systems, air traffic control, direct
-life support machines, or weapons systems, in which
-the failure of the Product could lead directly to
-death, personal injury, or severe physical or
-environmental damage ("High Risk Activities").
-Accordingly, Licensor and its suppliers specifically
-disclaim any express or implied warranty of fitness
-for High Risk Activities.  Licensee agrees that
-Licensor and its suppliers will not be liable for any
-claims or damages arising from the use of the Product
-in such applications.
-
-13. U.S. GOVERNMENT END USERS.  The Product is a
-"commercial item," as that term is defined in 48
-C.F.R. 2.101 (Oct. 1995), consisting of "commercial
-computer software" and "commercial computer software
-documentation," as such terms are used in 48 C.F.R.
-12.212 (Sept.  1995).  Consistent with 48 C.F.R.
-12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4
-(June 1995), all U.S. Government End Users acquire
-the Product with only those rights set forth herein.
-
-13. MISCELLANEOUS.  (a) This Agreement constitutes
-the entire agreement between the parties concerning
-the subject matter hereof.  (b) This Agreement may be
-amended only by a writing signed by both parties.
-(c) Except to the extent applicable law, if any,
-provides otherwise, this Agreement shall be governed
-by the laws of the State of California, U.S.A.,
-excluding its conflict of law provisions.  (d) Unless
-otherwise agreed in writing, all disputes relating to
-this Agreement (excepting any dispute relating to
-intellectual property rights) shall be subject to
-final and binding arbitration in Santa Clara County,
-California, under the auspices of JAMS/EndDispute,
-with the losing party paying all costs of
-arbitration.  (e) This Agreement shall not be
-governed by the United Nations Convention on
-Contracts for the International Sale of Goods.  (f)
-If any provision in this Agreement should be held
-illegal or unenforceable by a court having
-jurisdiction, such provision shall be modified to the
-extent necessary to render it enforceable without
-losing its intent, or severed from this Agreement if
-no such modification is possible, and other
-provisions of this Agreement shall remain in full
-force and effect.  (g) The controlling language of
-this Agreement is English.  If Licensee has received
-a translation into another language, it has been
-provided for Licensee's convenience only.  (h) A
-waiver by either party of any term or condition of
-this Agreement or any breach thereof, in any one
-instance, shall not waive such term or condition or
-any subsequent breach thereof.  (i) The provisions of
-this Agreement which require or contemplate
-performance after the expiration or termination of
-this Agreement shall be enforceable notwithstanding
-said expiration or termination.  (j) Licensee may not
-assign or otherwise transfer by operation of law or
-otherwise this Agreement or any rights or obligations
-herein except in the case of a merger or the sale of
-all or substantially all of Licensee's assets to
-another entity.  (k) This Agreement shall be binding
-upon and shall inure to the benefit of the parties,
-their successors and permitted assigns.  (l) Neither
-party shall be in default or be liable for any delay,
-failure in performance (excepting the obligation to
-pay) or interruption of service resulting directly or
-indirectly from any cause beyond its reasonable
-control.  (m) The relationship between Licensor and
-Licensee is that of independent contractors and
-neither Licensee nor its agents shall have any
-authority to bind Licensor in any way.  (n) If any
-dispute arises under this Agreement, the prevailing
-party shall be reimbursed by the other party for any
-and all legal fees and costs associated therewith.
-(o) If any Netscape professional services are being
-provided, then such professional services are
-provided pursuant to the terms of a separate
-Professional Services Agreement between Netscape and
-Licensee.  The parties acknowledge that such services
-are acquired independently of the Product licensed
-hereunder, and that provision of such services is not
-essential to the functionality of such Product.  (p)
-The headings to the sections of this Agreement are
-used for convenience only and shall have no
-substantive meaning.  (q) Licensor may use Licensee's
-name in any customer reference list or in any press
-release issued by Licensor regarding the licensing of
-the Product and/or provide Licensee's name and the
-names of the Product licensed by Licensee to third
-parties.
-
-14. LICENSEE OUTSIDE THE U.S.  If Licensee is located
-outside the U.S., then the provisions of this Section
-shall apply.  (i) Les parties aux presentes
-confirment leur volonte que cette convention de meme
-que tous les documents y compris tout avis qui s'y
-rattache, soient rediges en langue anglaise.
-(translation: "The parties confirm that this
-Agreement and all related documentation is and will
-be in the English language.")  (ii) Licensee is
-responsible for complying with any local laws in its
-jurisdiction which might impact its right to import,
-export or use the Product, and Licensee represents
-that it has complied with any regulations or
-registration procedures required by applicable law to
-make this license enforceable.
-
-
-Netscape Client Software EULA           Rev. [022500]
-

mozilla/security/psm/doc/psmtest.html

@@ -1,29 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
-<head>
-  <title>Personal Security Manager Detection Page</title>
-  <script language=javascript>
-
-    function init_title()
-    {
-      with(window.frames.the_frame) {
-        document.write('<BODY><H1>Personal Security Manager Detection Page</H1><P><P>');
-        if (typeof(crypto.version) == "undefined") {
-          document.write('<FONT color="#ff0000">Personal Security Manager not loaded</FONT>');
-        } else {
-          document.write('<FONT color="#007700">Personal Security Manager&nbsp;Running&nbsp;(version ', crypto.version); 
-          document.write(')</FONT>'); 
-        }
-        document.write('</BODY>');
-        document.close();
-      }
-    }
-  
-
-
-</script>
-</head>
-
-<frameset rows="*,1" border=0 onload="init_title()">
-  <frame src="about:blank" name="the_frame">
-  <frame src="about:blank">
-</frameset>

mozilla/security/psm/doc/release_notes.html

@@ -1,297 +0,0 @@
-<!DOCTYPE html PUBLIC "-//w3c//dtd html 4.0 transitional//en">
-<html>
-<head>
-   
-  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-   
-  <meta name="GENERATOR" content="Mozilla/4.75 [en] (WinNT; U) [Netscape]">
-   
-  <meta name="Author" content="Sean Cotter">
-  <title>Personal Security Manager Release Notes</title>
-</head>
-<body>
-<center>
-<h1><img src="bannerrn.gif" height="32" width="468" align="Center"></h1>
-</center>
-<center>
-<h2>Netscape Personal Security Manager</h2>
-</center>
-<center>
-<h2>Release 1.4</h2>
-</center>
-<center>
-<h2>12/18/2000</h2>
-</center>
-<center>
-<hr width="100%"></center>
-These release notes contain the most recent information about this release
-of Netscape Personal Security Manager. Please read these notes before using
-the software.
-<p>These notes include information for IS professionals who are thoroughly
-familiar with security and public-key infrastructure (PKI) issues.</p>
-<p>Use of this product is subject to the terms detailed in the license agreement
-at <a href="http://docs.iplanet.com/docs/manuals/psm/14/license.txt.">http://docs.iplanet.com/docs/manuals/psm/14/license.txt.</a></p>
-<p></p>
-<hr width="100%">
-<h2>Contents</h2>
-<a href="#Documentation">Documentation</a><br>
-<a href="#Changes Since PSM 1.3">Changes Since Personal Security Manager 1.3</a>
-<br>
-<a href="#Software/Hardware Requirements">Software/Hardware Requirements</a>
-<br>
-<a href="#unpacking">Installing Personal Security Manager</a><br>
-<a href="#Using the Test Bed">Using Personal Security Manager</a><br>
-<a href="#Known Bugs/Issues for 14 Release">Known Bugs/Issues for Personal
-Security Manager 1.4</a><br>
-<a href="#Feedback">Feedback</a>
-<p></p>
-<hr width="100%">
-<h2><a name="Documentation"></a>Documentation</h2>
-The following documentation is available with Personal Security Manager:
-<ul>
-  <li><a href="contents.htm">Personal Security Manager Help</a> -- This online
-help system can also be accessed by clicking the Help button in any personal
-Security Manager window.</li>
-  <li><a href="cmcjavascriptapi.html">JavaScript API for Client Certificate
-Management</a> -- This reference describes a new Javascript API for performing
-user certificate management operations with Personal Security Manager, including
-one-click issuance, forced certificate backup by end users, and automatic
-archival of encryption private keys.</li>
-</ul>
-For the latest release notes, deployment guide, and other information,see
-<a href="http://docs.iPlanet.com/docs/manuals/psm.html">http://docs.iPlanet.com/docs/manuals/psm.html</a><a href="http://developer.iPlanet.com/docs/manuals/psm.html">
-.</a>
-<p></p>
-<hr width="100%">
-<h2><a name="Changes Since PSM 1.3"></a>Changes Since Personal Security Manager
-1.3</h2>
-The <a href="http://www.ietf.org/rfc/rfc2246.txt">Transport Layer Security
-(TLS)</a> protocol is turned on by default in Personal Security Manager1.4.
-To turn TLS off, open Personal Security Manager, click the Advanced tab, click
-Options in the left frame, then deselect the checkbox labeled "Enable TLS."
-<p>TLS is an IETF standard based on the Secure Sockets Layer (SSL) protocol.
-It can be thought of as SSL version 3.1. Some servers that do not implement
-SSL correctly cannot negotiate the SSL handshake with client software (such
-as Personal Security Manager) that supports TLS. To allow Personal Security
-Manager to use SSL with such TLS-intolerant servers, you must disable TLS
-as described above.</p>
-<p>Most other changes since Personal Security Manager 1.3 involve minor bug
-fixes and optimizations.</p>
-<p>This version of Netscape Personal Security Manager ships with Netscape
-6 and also works with Mozilla and Communicator 4.7x. </p>
-<p></p>
-<hr width="100%">
-<h4><a name="Software/Hardware Requirements"></a><font size="+2">Software/Hardware
-Requirements</font></h4>
-<b>Operating systems supported:</b> Windows NT, Windows 95, Windows 98, Windows
-2000; Solaris 2.6, 2.7, 2.8; and Red Hat Linux 6.1.
-<p></p>
-<hr width="100%">
-<h2><a name="unpacking"></a>Installing Personal Security Manager</h2>
-Netscape Personal Security Manager 1.4 is installed with Netscape 6 and recent versions
-of Mozilla. 
-
-<p>When you install Netscape 6 on Windows, Personal Security Manager is installed
-in the directory <tt>C:\Program Files\Common Files\Netscape Shared\Security\</tt>.
-
-<p>When you install Netscape 6 on Unix, Personal Security Manager is installed
-in a directory called <tt>psm</tt> in the same directory where the <tt>netscape</tt>
-executable resides.<br>
-
-<p>The sections that follow describe how to install the Personal Security Manager 
-files for use with Communicator 4.7x.</p>
-<h3>Installing on Windows 95/98/2000/NT for Use With Communicator 4.7x</h3>
-
-To install Netscape Personal Security Manager on Windows 95/98/2000/NT for use with
-Communicator 4.7 or later, save the file in a convenient location with the
-specified filename, then drag the file's icon into a Navigator window (that
-is, a browser window displayed by Communicator). Dropping the file's icon
-over the browser window initiates SmartUpdate, which automatically installs
-Personal Security Manager. Afterinstallation is complete, exit Communicator
-and relaunch it. If your copy of Communicator is installed in the default
-location, SmartUpdate installs the Personal Security Manager files in the
-directory<tt>C:\Program Files\CommonFiles\Netscape Shared\Security\</tt>
-and adds the file <tt>cmnav.dll</tt>in the directory <tt>C:\Program Files\Netscape\Communicator\Program</tt>.<br>
-<h3>Installing on Unix for Use With Communicator 4.7x</h3>
-
-To install Personal Security Manager for use with Communicator 4.7 or later on Unix, you
-must be logged in as the same Unix user you will be logged in as when you
-run Communicator. For the Unix installation to succeed, you must have write
-privileges for both the directory where the Netscape executable resides and
-the directory where the installation script creates the directory containing
-the Personal Security Manager files. To install Personal Security Manager for
-use with Communicator 4.7x, download the tar file for the version of the product
-that you want to install and follow these steps:<br>
-<ol>
-  <li>Exit Communicator, if it is running.</li>
-  <li>Decompress the downloaded file to some convenient location.</li>
-  <li>Run the psm-install program.</li>
-</ol>
-The psm-install program allows you to specify the directory in which Personal
-Security Manager will be installed. In this release, you must install Personal
-Security Manager locally. To do so, you can either install it in the default
-location (<tt>/opt/netscape/security</tt>) or in some other local location. However,
-if you install Personal Security Manager anywhere other than the default
-location, Communicator must also be installed locally. To run Personal Security
-Manager on Unix, you must be logged in as the same Unix user you were logged
-in as when you installed it.<br>
-<h3>Disabling Personal Security Manager</h3>
-To <b>disable</b> Personal Security Manager temporarily, exit the browser,
-then:
-<ul>
-  <li>on Unix, remove the directory<tt>psm</tt> from the directory where
-the<tt>netscape</tt>executable resides.</li>
-  <li>on Windows, rename the directory <tt>C:\Program Files\Common Files\Netscape
-Shared\Security</tt> to something else.</li>
-</ul>
-<hr width="100%">
-<h2><a name="Using the Test Bed"></a>Using Personal Security Manager</h2>
-The sections that follow describe how to test some of the features of Personal
-Security Manager that are available with this release:
-<ul>
-  <li><a href="#Start Up Personal Security Manager with">Start Up Personal
-SecurityManager with Netscape 6</a></li>
-  <li><a href="#Use SSL with Server Authentication">Test Basic SSL</a></li>
-  <li><a href="#Get a Certificate">Get an SSL Client Certificate</a></li>
-  <li><a href="#View Your Personal Certificate">View Your Certificate</a></li>
-  <li><a href="#Using Your Personal Certificate for Client">Test Client Authentication</a></li>
-  <li><a href="#Validate Certificates Using OSCP">Validate Certificates Using
-OCSP</a></li>
-</ul>
-The sections that follow briefly describe how to test some of the features
-listed above.
-<p>For information on the JavaScript API supported by Personal SecurityManager,
-see <a href="cmcjavascriptapi.html">JavaScript API for ClientCertificate
-Management</a> and the Personal Security Manager DeploymentGuide. For the
-latest versions of these documents, see <a href="http://docs.iPlanet.com/docs/manuals/psm.html">
-http://docs.iPlanet.com/docs/manuals/psm.html</a>.</p>
-<h3><a name="Start Up Personal Security Manager with"></a>Use Personal Security
-Manager with Netscape 6</h3>
-Personal Security Manager starts automatically the first time Netscape 6
-needs to perform some action involving security, such as handling anSSL session.
-<p>Follow these steps to view your security settings and confirm that&nbsp;
-Personal Security Manager is running:</p>
-<ol>
-  <li>Launch Netscape 6.</li>
-  <li>Choose Security &amp; Privacy from the Tasks menu, then choose Security
-Manager to view your Personal Security Manager settings.</li>
-  <li>Close the Personal Security Manager window.</li>
-  <li>Go to the page <a href="psmtest.html">psmtest.html</a> (in the same
-directoryas these release notes), then choose Page Source from the View menu
-tosee the JavaScript code that a web programmer can use to detect Personal
-Security Manager and its version number.</li>
-</ol>
-Note that the version number has two parts. The first is the version ofthe
-PSM client library, and the second is the version of the PSM serverlibrary.
-<br>
-&nbsp;
-<h3><a name="Use SSL with Server Authentication"></a>Test Basic SSL</h3>
-Go to any online store, banking service, brokerage account, or other website
-that supports SSL. Verify that the lock in the lower-left corner ofthe browser
-window is closed when you reach the pages for which SSL shouldbe enabled,
-for example a page where you are asked to give your creditcard number.
-<h3><a name="Get a Certificate"></a>Get an SSL Client Certificate</h3>
-Go to any public or private CA and apply for an SSL client certificate.
-<p>To test one-click certificate issuance, dual key-pair certificates,and
-other Personal Security Manager features, system administrators shoulddownload,
-install, and configure Netscape Certificate Management System.For complete
-CMS documentation and other information, see <a href="http://docs.iPlanet.com/docs/manuals/cms.html">
-http://docs.iPlanet.com/docs/manuals/cms.html</a>.To download the latest
-version of CMS, see <a href="http://www.iplanet.com/downloads/download/">
-http://www.iplanet.com/downloads/download/</a>.</p>
-<h3><a name="View Your Personal Certificate"></a>View Your Certificate</h3>
-After you have obtained a certificate, follow these steps to view it:
-<ol>
-  <li>Click the Security icon in the Navigator toolbar.</li>
-  <li>Click the Certificates tab.</li>
-  <li>Click to select your certificate.</li>
-  <li>Click View.</li>
-</ol>
-You should see information about your new certificate.
-<h3><a name="Using Your Personal Certificate for Client"></a><font size="+1">
-TestClient Authentication</font></h3>
-Personal Security Manager allows the SSL server and client to negotiatewhich
-certificate to use, and in most cases they can agree on a singlecorrect certificate
-for the client to present. When this happens, the usercan access an SSL site
-that requires client authentication with zero additionalclicks.
-<p>To test client authentication with Netscape Enterprise Server, systemadministrators
-should follow these steps:</p>
-<ul>
-  <li>Install an Enterprise Server and configure it for client authentication
-as described in <a href="http://docs.iplanet.com/docs/manuals/cms/41/dep_gide/entsrv.htm">
-AppendixD, Using SSL with Enterprise Server 3.x</a>, of <i>Netscape Certificate
-Management System Installation and Deployment Guide</i>.</li>
-  <li>Test the Enterprise Server installation as described at the end of
-AppendixD using Personal Security Manager.</li>
-</ul>
-<h3><a name="Validate Certificates Using OSCP"></a>Validate Certificates
-UsingOSCP</h3>
-Personal Security Manager supports the use of the On-Line Certificate Status
-Protocol (OSCP) to check the validity of certificates in real time. Information
-about this protocol and how configure Personal Security Manager 1.3 andNetscape
-Certificate Management System 4.2 to support it is available from<a href="http://docs.iPlanet.com/docs/manuals/psm/12/psmdply.htm">
-http://docs.iPlanet.com/docs/manuals/psm/12/psmdply.htm</a>
-<p>It's important to note that Personal Security Manager will accept signatures
-from responders only under the following conditions:</p>
-<ul>
-  <li>The response was signed by a delegated responder--that is, the responder's
-certificate was signed by the same CA as the certificate&nbsp; you're trying
-to verify and has the <tt>extendedKeyUsage</tt> bit set indicating thatthe
-certificate is an OCSP response signer. The certificate should be thesame
-as a CA certificate with the addition of the <tt>extendedKeyUsage</tt>bit.</li>
-  <li>The user has designated a default responder in the OCSP Settings dialog
-box (available from the Advanced tab under Options).</li>
-</ul>
-Common problems include the following:
-<ul>
-  <li>Time drift between the client and server machine. Personal Security
-Managerexpects the time of the response to be within the past 24 hours. If
-thereis a difference in the clocks between the machine used to sign the response,
-so the response looks to Personal Security Manager like it was signed inthe
-future, Personal Security Manager interprets this as an error. Runntp on
-both machines to fix this problem.</li>
-  <li>The response doesn't include the certificates required to complete
-thechain needed to verify the signer's certificate. The client frequently
-doesn't have all the certificates in the database that are needed to verify
-the signer's certificate, in which case Personal Security Manager can'tverify
-the signer's certificate and OCSP fails. Make sure the entire chainis included
-with every response. This is the safest way to avoid this problem.</li>
-  <li>If you are using ValiCert, misconfiguration may cause the Validation
-Authoritynot to send the certificate chain (including the CA root certificate
-andthe OCSP responder's certificate) correctly.</li>
-</ul>
-<hr width="100%">
-<h2><a name="Known Bugs/Issues for 14 Release"></a>Known Bugs/Issues for
-Personal Security Manager 1.4</h2>
-<ul>
-  <li>To run Personal Security Manager on Unix with Netscape 6 or Communicator,
-you must be logged in as thesame Unix user you were logged in as when the
-browser was installed.</li>
-  <li>FORTEZZA is not guaranteed to work with this release. [# 94220]</li>
-  <li>In some unusual circumstances you may encounter problems such as valid
-certificates not being verified or the browser freezing up. If you encounter
-a problem that doesn't appear to have a logical explanation, try the following
-as a last resort:</li>
-  <ol>
-    <li>Exit the browser, then relaunch it. If necessary, use Control-Alt-Delete
-on Windows 95/98/2000/NT to bring up the Task Manager and click End Process
-for both <tt>psm.exe</tt> and <tt>netscp6.exe</tt>.</li>
-    <li><b>Warning:</b> <b>Before taking this step, back up your own certificates
-stored internally by Personal Security Manager.</b> If exiting and relaunching
-the browser doesn't take care of the problem, in some rare cases it maywork
-to exit the browser, then delete or rename your <tt>cert7.db</tt> and<tt>
-key3.db</tt>files (located in your user profile directory on Windows 95/98/2000/NT,
-or in the directory in which the Netscape or Mozilla executable resideson
-Unix) and relaunch the browser. You should also look for all otherfiles in
-the same directory that begin with <tt>cert</tt> or<tt>key</tt>and end in
-      <tt>.db</tt> and delete those files as well before relaunchingthe browser.</li>
-  </ol>
-</ul>
-<hr width="100%">
-<h2><a name="Feedback"></a>Feedback</h2>
-To send feedback to the Personal Security Manager development team, send email
-to <a href="mailto:psmfeedback@netscape.com">psmfeedback@netscape.com</a>. 
-Feedback back sent to this address will be read by the team, but you will
-not receive a personal response.
-</body>
-</html>

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/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,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.
-# 
-
-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)
-
-ifeq ($(MOZ_OS2_TOOLS),VACPP)
-EXTRA_DSO_LDOPTS	+= $(DIST)/lib/protocol.$(LIB_SUFFIX)
-else
-EXTRA_DSO_LDOPTS	+= -L$(DIST)/lib -lprotocol
-endif
-
-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.
- */
-#if defined(XP_UNIX) || defined(XP_BEOS) || defined(XP_OS2)
-#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,490 +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.
- */
-#if defined(XP_UNIX) || defined(XP_BEOS) || defined(XP_OS2)
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <sys/stat.h>
-#ifndef XP_BEOS
-#include <netinet/tcp.h>
-#endif
-#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>
-
-#if defined(XP_UNIX) || defined(XP_BEOS)
-#define DIRECTORY_SEPARATOR '/'
-#elif defined(WIN32) || defined(XP_OS2)
-#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) || defined(XP_BEOS)
-    return getcwd(buf, maxLen);
-#else
-    return NULL;
-#endif
-}
-
-static void
-setWorkingDir(char *path)
-{
-#if defined WIN32
-    _chdir(path);
-#elif defined(XP_UNIX) || defined(XP_BEOS)
-    chdir(path);
-#else
-    return;
-#endif
-}
-
-static CMTStatus
-launch_psm(char *executable)
-{
-#ifndef XP_MAC
-    char command[MAX_PATH_LEN];
-#endif
-#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) || defined(XP_BEOS)
-    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;
-#ifndef XP_MAC
-    char *executable;
-    char *newWorkingDir;
-    char oldWorkingDir[MAX_PATH_LEN];
-    size_t stringLen;
-#endif    
-    int i;
-    char *path = NULL;
-
-    /*	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) || defined(XP_BEOS)
-    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,664 +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.
- */
-#if defined(XP_UNIX) || defined(XP_BEOS) || defined(XP_OS2)
-#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];
-#ifndef XP_MAC
-    int numTries = 0;
-#endif
-
-    /* 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.
-     * There are some cases where the server doesn't put up data fast 
-     * enough, so we should loop on this poll instead of just trying it
-     * once.
-     */
-#ifndef XP_MAC
- poll_sockets:
-    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;
-                }
-                if (priv->cb)
-                    priv->cb(priv->cb_arg, buf, nbytes);
-            }
-        }
-    }
-#ifndef XP_MAC
-    else {
-#ifdef WIN32
-        if (numTries < 20) {
-            Sleep(100);
-            numTries++;
-            goto poll_sockets;
-        }
-#endif
-#ifdef XP_UNIX
-	if (numTries < 25) {
-	  numTries += sleep(1);
-	  goto poll_sockets;
-	}
-#endif
-    }
-#endif
-    
-    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;
-    char checkMessageForError = 0;
-
-    /* Do some parameter checking */
-    if (!control || !scertRID || !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;
-    }
-    checkMessageForError = 1;
-    /* 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 (checkMessageForError && 
-	CMT_DecodeMessage(SingleNumMessageTemplate, 
-			  &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;
-    CMInt32 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.
- */
-#if defined(XP_UNIX) || defined(XP_BEOS) || defined(XP_OS2)
-#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.
- */
-#if defined(XP_UNIX) || defined(XP_BEOS) || defined(XP_OS2)
-#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,648 +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.
- */
-#if defined(XP_UNIX) || defined(XP_BEOS) || defined(XP_OS2)
-#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_ReadMessageDispatchEvents(PCMT_CONTROL control, CMTItem* message)
-{
-    CMTStatus status;
-    CMBool done = CM_FALSE;
-    CMUint32 msgCategory;
-    
-    /* 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;
-        }
-    }
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_SendMessage(PCMT_CONTROL control, CMTItem* message)
-{
-	CMTStatus status;
-#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;
-	}
-
-    if (CMT_ReadMessageDispatchEvents(control, message) != CMTSuccess) {
-        goto loser;
-    }
-    /* 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;
-
-    /* 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;
-
-    /* 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;
-
-    if (!control) return rv;
-
-    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,77 +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);
-CMTStatus CMT_ReadMessageDispatchEvents(PCMT_CONTROL control, 
-					CMTItem* message);
-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,130 +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)
-
-EXPORTS = \
-    .\cmtcmn.h \
-    .\cmtclist.h \
-    $(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        =
-