merge with debian-experimental 0.8.16~exp2 release

47 files changed, 1954 insertions, 858 deletions

diff --git a/apt-pkg/acquire-item.cc b/apt-pkg/acquire-item.cc
index 6785b4e1b..d790bd898 100644
--- a/apt-pkg/acquire-item.cc
+++ b/apt-pkg/acquire-item.cc
@@ -271,6 +271,14 @@ void pkgAcqSubIndex::Done(string Message,unsigned long Size,string Md5Hash,	/*{{
 
    string FinalFile = _config->FindDir("Dir::State::lists")+URItoFileName(Desc.URI);
 
+   /* Downloaded invalid transindex => Error (LP: #346386) (Closes: #627642) */
+   indexRecords SubIndexParser;
+   if (FileExists(DestFile) == true && !SubIndexParser.Load(DestFile)) {
+      Status = StatError;
+      ErrorText = SubIndexParser.ErrorText;
+      return;
+   }
+
    // sucess in downloading the index
    // rename the index
    if(Debug)
@@ -894,6 +902,30 @@ void pkgAcqIndex::Done(string Message,unsigned long Size,string Hash,
 	 ReportMirrorFailure("HashChecksumFailure");
          return;
       }
+
+      /* Verify the index file for correctness (all indexes must
+       * have a Package field) (LP: #346386) (Closes: #627642) */
+      {
+	 FileFd fd(DestFile, FileFd::ReadOnly);
+	 pkgTagSection sec;
+	 pkgTagFile tag(&fd);
+
+         // Only test for correctness if the file is not empty (empty is ok)
+         if (fd.Size() > 0) {
+            if (_error->PendingError() || !tag.Step(sec)) {
+               Status = StatError;
+               _error->DumpErrors();
+               Rename(DestFile,DestFile + ".FAILED");
+               return;
+            } else if (!sec.Exists("Package")) {
+               Status = StatError;
+               ErrorText = ("Encountered a section with no Package: header");
+               Rename(DestFile,DestFile + ".FAILED");
+               return;
+            }
+         }
+      }
+       
       // Done, move it into position
       string FinalFile = _config->FindDir("Dir::State::lists");
       FinalFile += URItoFileName(RealURI);
@@ -1330,6 +1362,16 @@ void pkgAcqMetaIndex::AuthDone(string Message)				/*{{{*/
 									/*}}}*/
 void pkgAcqMetaIndex::QueueIndexes(bool verify)				/*{{{*/
 {
+#if 0
+   /* Reject invalid, existing Release files (LP: #346386) (Closes: #627642)
+    * FIXME: Disabled; it breaks unsigned repositories without hashes */
+   if (!verify && FileExists(DestFile) && !MetaIndexParser->Load(DestFile))
+   {
+      Status = StatError;
+      ErrorText = MetaIndexParser->ErrorText;
+      return;
+   }
+#endif
    for (vector <struct IndexTarget*>::const_iterator Target = IndexTargets->begin();
         Target != IndexTargets->end();
         Target++)
@@ -1493,6 +1535,12 @@ void pkgAcqMetaIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 			 LookupTag(Message,"Message").c_str());
 	 RunScripts("APT::Update::Auth-Failure");
 	 return;
+      } else if (LookupTag(Message,"Message").find("NODATA") != string::npos) {
+	 /* Invalid signature file, reject (LP: #346386) (Closes: #627642) */
+	 _error->Error(_("GPG error: %s: %s"),
+			 Desc.Description.c_str(),
+			 LookupTag(Message,"Message").c_str());
+	 return;
       } else {
 	 _error->Warning(_("GPG error: %s: %s"),
 			 Desc.Description.c_str(),
@@ -1682,6 +1730,8 @@ bool pkgAcqArchive::QueueNext()
       string PkgFile = Parse.FileName();
       if (ForceHash.empty() == false)
       {
+	 if(stringcasecmp(ForceHash, "sha512") == 0)
+	    ExpectedHash = HashString("SHA512", Parse.SHA512Hash());
 	 if(stringcasecmp(ForceHash, "sha256") == 0)
 	    ExpectedHash = HashString("SHA256", Parse.SHA256Hash());
 	 else if (stringcasecmp(ForceHash, "sha1") == 0)
@@ -1692,7 +1742,9 @@ bool pkgAcqArchive::QueueNext()
       else
       {
 	 string Hash;
-	 if ((Hash = Parse.SHA256Hash()).empty() == false)
+	 if ((Hash = Parse.SHA512Hash()).empty() == false)
+	    ExpectedHash = HashString("SHA512", Hash);
+	 else if ((Hash = Parse.SHA256Hash()).empty() == false)
 	    ExpectedHash = HashString("SHA256", Hash);
 	 else if ((Hash = Parse.SHA1Hash()).empty() == false)
 	    ExpectedHash = HashString("SHA1", Hash);
diff --git a/apt-pkg/acquire-method.cc b/apt-pkg/acquire-method.cc
index e9e102488..8c353beb2 100644
--- a/apt-pkg/acquire-method.cc
+++ b/apt-pkg/acquire-method.cc
@@ -166,6 +166,8 @@ void pkgAcqMethod::URIDone(FetchResult &Res, FetchResult *Alt)
       std::cout << "SHA1-Hash: " << Res.SHA1Sum << "\n";
    if (Res.SHA256Sum.empty() == false)
       std::cout << "SHA256-Hash: " << Res.SHA256Sum << "\n";
+   if (Res.SHA512Sum.empty() == false)
+      std::cout << "SHA512-Hash: " << Res.SHA512Sum << "\n";
    if (UsedMirror.empty() == false)
       std::cout << "UsedMirror: " << UsedMirror << "\n";
    if (Res.GPGVOutput.empty() == false)
@@ -199,7 +201,9 @@ void pkgAcqMethod::URIDone(FetchResult &Res, FetchResult *Alt)
 	 std::cout << "Alt-SHA1-Hash: " << Alt->SHA1Sum << "\n";
       if (Alt->SHA256Sum.empty() == false)
 	 std::cout << "Alt-SHA256-Hash: " << Alt->SHA256Sum << "\n";
-
+      if (Alt->SHA512Sum.empty() == false)
+         std::cout << "Alt-SHA512-Hash: " << Alt->SHA512Sum << "\n";
+     
       if (Alt->IMSHit == true)
 	 std::cout << "Alt-IMS-Hit: true\n";
    }
@@ -460,5 +464,6 @@ void pkgAcqMethod::FetchResult::TakeHashes(Hashes &Hash)
    MD5Sum = Hash.MD5.Result();
    SHA1Sum = Hash.SHA1.Result();
    SHA256Sum = Hash.SHA256.Result();
+   SHA512Sum = Hash.SHA512.Result();
 }
 									/*}}}*/
diff --git a/apt-pkg/acquire-method.h b/apt-pkg/acquire-method.h
index 72efa8065..2d0fa4590 100644
--- a/apt-pkg/acquire-method.h
+++ b/apt-pkg/acquire-method.h
@@ -46,6 +46,7 @@ class pkgAcqMethod
       string MD5Sum;
       string SHA1Sum;
       string SHA256Sum;
+      string SHA512Sum;
       vector<string> GPGVOutput;
       time_t LastModified;
       bool IMSHit;
diff --git a/apt-pkg/acquire-worker.h b/apt-pkg/acquire-worker.h
index 06283922e..62545829a 100644
--- a/apt-pkg/acquire-worker.h
+++ b/apt-pkg/acquire-worker.h
@@ -44,6 +44,9 @@
  */
 class pkgAcquire::Worker : public WeakPointable
 {
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+  
    friend class pkgAcquire;
    
    protected:
@@ -314,7 +317,7 @@ class pkgAcquire::Worker : public WeakPointable
     *  Closes the file descriptors; if MethodConfig::NeedsCleanup is
     *  \b false, also rudely interrupts the worker with a SIGINT.
     */
-   ~Worker();
+   virtual ~Worker();
 };
 
 /** @} */
diff --git a/apt-pkg/acquire.h b/apt-pkg/acquire.h
index e3a4435b8..7db7a9958 100644
--- a/apt-pkg/acquire.h
+++ b/apt-pkg/acquire.h
@@ -91,6 +91,12 @@ class pkgAcquireStatus;
  */
 class pkgAcquire
 {   
+   private:
+   /** \brief FD of the Lock file we acquire in Setup (if any) */
+   int LockFD;
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+
    public:
    
    class Item;
@@ -359,9 +365,6 @@ class pkgAcquire
     */
    virtual ~pkgAcquire();
 
-   private:
-   /** \brief FD of the Lock file we acquire in Setup (if any) */
-   int LockFD;
 };
 
 /** \brief Represents a single download source from which an item
@@ -391,6 +394,9 @@ class pkgAcquire::Queue
    friend class pkgAcquire::UriIterator;
    friend class pkgAcquire::Worker;
 
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+
    /** \brief The next queue in the pkgAcquire object's list of queues. */
    Queue *Next;
    
@@ -540,12 +546,15 @@ class pkgAcquire::Queue
    /** Shut down all the worker processes associated with this queue
     *  and empty the queue.
     */
-   ~Queue();
+   virtual ~Queue();
 };
 									/*}}}*/
 /** \brief Iterates over all the URIs being fetched by a pkgAcquire object.	{{{*/
 class pkgAcquire::UriIterator
 {
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+
    /** The next queue to iterate over. */
    pkgAcquire::Queue *CurQ;
    /** The item that we currently point at. */
@@ -581,11 +590,15 @@ class pkgAcquire::UriIterator
 	 CurQ = CurQ->Next;
       }
    }   
+   virtual ~UriIterator() {};
 };
 									/*}}}*/
 /** \brief Information about the properties of a single acquire method.	{{{*/
 struct pkgAcquire::MethodConfig
 {
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+   
    /** \brief The next link on the acquire method list.
     *
     *  \todo Why not an STL container?
@@ -634,6 +647,9 @@ struct pkgAcquire::MethodConfig
     *  appropriate.
     */
    MethodConfig();
+
+   /* \brief Destructor, empty currently */
+   virtual ~MethodConfig() {};
 };
 									/*}}}*/
 /** \brief A monitor object for downloads controlled by the pkgAcquire class.	{{{
@@ -644,6 +660,9 @@ struct pkgAcquire::MethodConfig
  */
 class pkgAcquireStatus
 {
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+
    protected:
    
    /** \brief The last time at which this monitor object was updated. */
diff --git a/apt-pkg/algorithms.h b/apt-pkg/algorithms.h
index 582cbc527..050934bad 100644
--- a/apt-pkg/algorithms.h
+++ b/apt-pkg/algorithms.h
@@ -78,6 +78,9 @@ private:
 									/*}}}*/
 class pkgProblemResolver						/*{{{*/
 {
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+
    pkgDepCache &Cache;
    typedef pkgCache::PkgIterator PkgIterator;
    typedef pkgCache::VerIterator VerIterator;
diff --git a/apt-pkg/aptconfiguration.cc b/apt-pkg/aptconfiguration.cc
index ca602d4bf..e8c8e73d0 100644
--- a/apt-pkg/aptconfiguration.cc
+++ b/apt-pkg/aptconfiguration.cc
@@ -224,7 +224,7 @@ std::vector<std::string> const Configuration::getLanguages(bool const &All,
 		environment.push_back("en");
 	}
 
-	// Support settings like Acquire::Translation=none on the command line to
+	// Support settings like Acquire::Languages=none on the command line to
 	// override the configuration settings vector of languages.
 	string const forceLang = _config->Find("Acquire::Languages","");
 	if (forceLang.empty() == false) {
diff --git a/apt-pkg/cachefile.h b/apt-pkg/cachefile.h
index 09d3ec267..d07337d38 100644
--- a/apt-pkg/cachefile.h
+++ b/apt-pkg/cachefile.h
@@ -25,6 +25,9 @@
 
 class pkgCacheFile
 {
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+
    protected:
    
    MMap *Map;
diff --git a/apt-pkg/cachefilter.h b/apt-pkg/cachefilter.h
index e7ab1723f..5d426008b 100644
--- a/apt-pkg/cachefilter.h
+++ b/apt-pkg/cachefilter.h
@@ -16,6 +16,8 @@ namespace APT {
 namespace CacheFilter {
 // PackageNameMatchesRegEx						/*{{{*/
 class PackageNameMatchesRegEx {
+         /** \brief dpointer placeholder (for later in case we need it) */
+         void *d;
 	regex_t* pattern;
 public:
 	PackageNameMatchesRegEx(std::string const &Pattern);
diff --git a/apt-pkg/clean.h b/apt-pkg/clean.h
index 2aee2bf54..1ebf68dc9 100644
--- a/apt-pkg/clean.h
+++ b/apt-pkg/clean.h
@@ -15,6 +15,9 @@
 
 class pkgArchiveCleaner
 {
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+
    protected:
    
    virtual void Erase(const char * /*File*/,string /*Pkg*/,string /*Ver*/,struct stat & /*St*/) {};
diff --git a/apt-pkg/contrib/hashes.cc b/apt-pkg/contrib/hashes.cc
index 985d89d90..66ae33146 100644
--- a/apt-pkg/contrib/hashes.cc
+++ b/apt-pkg/contrib/hashes.cc
@@ -23,7 +23,7 @@
 
 const char* HashString::_SupportedHashes[] = 
 {
-   "SHA256", "SHA1", "MD5Sum", NULL
+   "SHA512", "SHA256", "SHA1", "MD5Sum", NULL
 };
 
 HashString::HashString()
@@ -57,6 +57,7 @@ bool HashString::VerifyFile(string filename) const			/*{{{*/
    MD5Summation MD5;
    SHA1Summation SHA1;
    SHA256Summation SHA256;
+   SHA256Summation SHA512;
    string fileHash;
 
    FileFd Fd(filename, FileFd::ReadOnly);
@@ -75,6 +76,11 @@ bool HashString::VerifyFile(string filename) const			/*{{{*/
       SHA256.AddFD(Fd.Fd(), Fd.Size());
       fileHash = (string)SHA256.Result();
    }
+   else if (Type == "SHA512") 
+   {
+      SHA512.AddFD(Fd.Fd(), Fd.Size());
+      fileHash = (string)SHA512.Result();
+   }
    Fd.Close();
 
    if(_config->FindB("Debug::Hashes",false) == true)
@@ -119,6 +125,7 @@ bool Hashes::AddFD(int Fd,unsigned long Size)
       MD5.Add(Buf,Res);
       SHA1.Add(Buf,Res);
       SHA256.Add(Buf,Res);
+      SHA512.Add(Buf,Res);
    }
    return true;
 }
diff --git a/apt-pkg/contrib/hashes.h b/apt-pkg/contrib/hashes.h
index 264f7fe90..4b6a08b1f 100644
--- a/apt-pkg/contrib/hashes.h
+++ b/apt-pkg/contrib/hashes.h
@@ -16,7 +16,7 @@
 
 #include <apt-pkg/md5.h>
 #include <apt-pkg/sha1.h>
-#include <apt-pkg/sha256.h>
+#include <apt-pkg/sha2.h>
 
 #include <algorithm>
 #include <vector>
@@ -60,10 +60,11 @@ class Hashes
    MD5Summation MD5;
    SHA1Summation SHA1;
    SHA256Summation SHA256;
+   SHA512Summation SHA512;
    
    inline bool Add(const unsigned char *Data,unsigned long Size)
    {
-      return MD5.Add(Data,Size) && SHA1.Add(Data,Size) && SHA256.Add(Data,Size);
+      return MD5.Add(Data,Size) && SHA1.Add(Data,Size) && SHA256.Add(Data,Size) && SHA512.Add(Data,Size);
    };
    inline bool Add(const char *Data) {return Add((unsigned char *)Data,strlen(Data));};
    bool AddFD(int Fd,unsigned long Size);
diff --git a/apt-pkg/contrib/hashsum_template.h b/apt-pkg/contrib/hashsum_template.h
new file mode 100644
index 000000000..7667baf92
--- /dev/null
+++ b/apt-pkg/contrib/hashsum_template.h
@@ -0,0 +1,87 @@
+// -*- mode: cpp; mode: fold -*-
+// Description                                                          /*{{{*/
+// $Id: hashsum_template.h,v 1.3 2001/05/07 05:05:47 jgg Exp $
+/* ######################################################################
+
+   HashSumValueTemplate - Generic Storage for a hash value
+   
+   ##################################################################### */
+                                                                        /*}}}*/
+#ifndef APTPKG_HASHSUM_TEMPLATE_H
+#define APTPKG_HASHSUM_TEMPLATE_H
+
+#include <string>
+#include <cstring>
+#include <algorithm>
+#include <stdint.h>
+
+using std::string;
+using std::min;
+
+template<int N>
+class HashSumValue
+{
+   unsigned char Sum[N/8];
+   
+   public:
+
+   // Accessors
+   bool operator ==(const HashSumValue &rhs) const
+   {
+      return memcmp(Sum,rhs.Sum,sizeof(Sum)) == 0;
+   }; 
+
+   string Value() const
+   {
+      char Conv[16] =
+      { '0','1','2','3','4','5','6','7','8','9','a','b',
+        'c','d','e','f'
+      };
+      char Result[((N/8)*2)+1];
+      Result[(N/8)*2] = 0;
+      
+      // Convert each char into two letters
+      int J = 0;
+      int I = 0;
+      for (; I != (N/8)*2; J++,I += 2)
+      {
+         Result[I] = Conv[Sum[J] >> 4];
+         Result[I + 1] = Conv[Sum[J] & 0xF];
+      }
+      return string(Result);
+   };
+   
+   inline void Value(unsigned char S[N/8])
+   {
+      for (int I = 0; I != sizeof(Sum); I++) 
+         S[I] = Sum[I];
+   };
+
+   inline operator string() const 
+   {
+      return Value();
+   };
+
+   bool Set(string Str) 
+   {
+      return Hex2Num(Str,Sum,sizeof(Sum));
+   };
+
+   inline void Set(unsigned char S[N/8]) 
+   {
+      for (int I = 0; I != sizeof(Sum); I++) 
+         Sum[I] = S[I];
+   };
+
+   HashSumValue(string Str) 
+   {
+         memset(Sum,0,sizeof(Sum));
+         Set(Str);
+   }
+   HashSumValue()
+   {
+      memset(Sum,0,sizeof(Sum));
+   }
+};
+
+#endif
diff --git a/apt-pkg/contrib/md5.cc b/apt-pkg/contrib/md5.cc
index c0fa8493d..6c60ffd74 100644
--- a/apt-pkg/contrib/md5.cc
+++ b/apt-pkg/contrib/md5.cc
@@ -165,61 +165,6 @@ static void MD5Transform(uint32_t buf[4], uint32_t const in[16])
    buf[3] += d;
 }
 									/*}}}*/
-// MD5SumValue::MD5SumValue - Constructs the summation from a string	/*{{{*/
-// ---------------------------------------------------------------------
-/* The string form of a MD5 is a 32 character hex number */
-MD5SumValue::MD5SumValue(string Str)
-{
-   memset(Sum,0,sizeof(Sum));
-   Set(Str);
-}
-									/*}}}*/
-// MD5SumValue::MD5SumValue - Default constructor			/*{{{*/
-// ---------------------------------------------------------------------
-/* Sets the value to 0 */
-MD5SumValue::MD5SumValue()
-{
-   memset(Sum,0,sizeof(Sum));
-}
-									/*}}}*/
-// MD5SumValue::Set - Set the sum from a string				/*{{{*/
-// ---------------------------------------------------------------------
-/* Converts the hex string into a set of chars */
-bool MD5SumValue::Set(string Str)
-{
-   return Hex2Num(Str,Sum,sizeof(Sum));
-}
-									/*}}}*/
-// MD5SumValue::Value - Convert the number into a string		/*{{{*/
-// ---------------------------------------------------------------------
-/* Converts the set of chars into a hex string in lower case */
-string MD5SumValue::Value() const
-{
-   char Conv[16] = {'0','1','2','3','4','5','6','7','8','9','a','b',
-                    'c','d','e','f'};
-   char Result[33];
-   Result[32] = 0;
-   
-   // Convert each char into two letters
-   int J = 0;
-   int I = 0;
-   for (; I != 32; J++, I += 2)
-   {
-      Result[I] = Conv[Sum[J] >> 4];
-      Result[I + 1] = Conv[Sum[J] & 0xF];
-   } 
-
-   return string(Result);
-}
-									/*}}}*/
-// MD5SumValue::operator == - Comparitor				/*{{{*/
-// ---------------------------------------------------------------------
-/* Call memcmp on the buffer */
-bool MD5SumValue::operator ==(const MD5SumValue &rhs) const
-{
-   return memcmp(Sum,rhs.Sum,sizeof(Sum)) == 0;
-}
-									/*}}}*/
 // MD5Summation::MD5Summation - Initialize the summer			/*{{{*/
 // ---------------------------------------------------------------------
 /* This assigns the deep magic initial values */
@@ -353,7 +298,7 @@ MD5SumValue MD5Summation::Result()
    }
    
    MD5SumValue V;
-   memcpy(V.Sum,buf,16);
+   V.Set((char *)buf);
    return V;
 }
 									/*}}}*/
diff --git a/apt-pkg/contrib/md5.h b/apt-pkg/contrib/md5.h
index 96c8975b4..9cc88cfbe 100644
--- a/apt-pkg/contrib/md5.h
+++ b/apt-pkg/contrib/md5.h
@@ -32,28 +32,11 @@
 using std::string;
 using std::min;
 
-class MD5Summation;
+#include "hashsum_template.h"
 
-class MD5SumValue
-{
-   friend class MD5Summation;
-   unsigned char Sum[4*4];
-   
-   public:
-
-   // Accessors
-   bool operator ==(const MD5SumValue &rhs) const; 
-   string Value() const;
-   inline void Value(unsigned char S[16]) 
-         {for (int I = 0; I != sizeof(Sum); I++) S[I] = Sum[I];};
-   inline operator string() const {return Value();};
-   bool Set(string Str);
-   inline void Set(unsigned char S[16]) 
-         {for (int I = 0; I != sizeof(Sum); I++) Sum[I] = S[I];};
+class MD5Summation;
 
-   MD5SumValue(string Str);
-   MD5SumValue();
-};
+typedef HashSumValue<128> MD5SumValue;
 
 class MD5Summation
 {
diff --git a/apt-pkg/contrib/sha1.cc b/apt-pkg/contrib/sha1.cc
index eae52d52f..0b1c16dc3 100644
--- a/apt-pkg/contrib/sha1.cc
+++ b/apt-pkg/contrib/sha1.cc
@@ -178,67 +178,6 @@ static void SHA1Transform(uint32_t state[5],uint8_t const buffer[64])
 }
 									/*}}}*/
 
-// SHA1SumValue::SHA1SumValue - Constructs the summation from a string  /*{{{*/
-// ---------------------------------------------------------------------
-/* The string form of a SHA1 is a 40 character hex number */
-SHA1SumValue::SHA1SumValue(string Str)
-{
-   memset(Sum,0,sizeof(Sum));
-   Set(Str);
-}
-
-									/*}}} */
-// SHA1SumValue::SHA1SumValue - Default constructor                     /*{{{*/
-// ---------------------------------------------------------------------
-/* Sets the value to 0 */
-SHA1SumValue::SHA1SumValue()
-{
-   memset(Sum,0,sizeof(Sum));
-}
-
-									/*}}} */
-// SHA1SumValue::Set - Set the sum from a string                        /*{{{*/
-// ---------------------------------------------------------------------
-/* Converts the hex string into a set of chars */
-bool SHA1SumValue::Set(string Str)
-{
-   return Hex2Num(Str,Sum,sizeof(Sum));
-}
-
-									/*}}} */
-// SHA1SumValue::Value - Convert the number into a string               /*{{{*/
-// ---------------------------------------------------------------------
-/* Converts the set of chars into a hex string in lower case */
-string SHA1SumValue::Value() const
-{
-   char Conv[16] =
-      { '0','1','2','3','4','5','6','7','8','9','a','b',
-      'c','d','e','f'
-   };
-   char Result[41];
-   Result[40] = 0;
-
-   // Convert each char into two letters
-   int J = 0;
-   int I = 0;
-   for (; I != 40; J++,I += 2)
-   {
-      Result[I] = Conv[Sum[J] >> 4];
-      Result[I + 1] = Conv[Sum[J] & 0xF];
-   }
-
-   return string(Result);
-}
-
-									/*}}} */
-// SHA1SumValue::operator == - Comparator                               /*{{{*/
-// ---------------------------------------------------------------------
-/* Call memcmp on the buffer */
-bool SHA1SumValue::operator == (const SHA1SumValue & rhs) const
-{
-   return memcmp(Sum,rhs.Sum,sizeof(Sum)) == 0;
-}
-									/*}}}*/
 // SHA1Summation::SHA1Summation - Constructor                           /*{{{*/
 // ---------------------------------------------------------------------
 /* */
@@ -290,11 +229,13 @@ SHA1SumValue SHA1Summation::Result()
 
    // Transfer over the result
    SHA1SumValue Value;
+   char res[20];
    for (unsigned i = 0; i < 20; i++)
    {
-      Value.Sum[i] = (unsigned char)
+      res[i] = (unsigned char)
 	 ((state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
    }
+   Value.Set(res);
    return Value;
 }
 									/*}}}*/
diff --git a/apt-pkg/contrib/sha1.h b/apt-pkg/contrib/sha1.h
index 8ddd889f1..e7683fa7b 100644
--- a/apt-pkg/contrib/sha1.h
+++ b/apt-pkg/contrib/sha1.h
@@ -21,28 +21,11 @@
 using std::string;
 using std::min;
 
-class SHA1Summation;
+#include "hashsum_template.h"
 
-class SHA1SumValue
-{
-   friend class SHA1Summation;
-   unsigned char Sum[20];
-   
-   public:
-
-   // Accessors
-   bool operator ==(const SHA1SumValue &rhs) const; 
-   string Value() const;
-   inline void Value(unsigned char S[20])
-         {for (int I = 0; I != sizeof(Sum); I++) S[I] = Sum[I];};
-   inline operator string() const {return Value();};
-   bool Set(string Str);
-   inline void Set(unsigned char S[20]) 
-         {for (int I = 0; I != sizeof(Sum); I++) Sum[I] = S[I];};
+class SHA1Summation;
 
-   SHA1SumValue(string Str);
-   SHA1SumValue();
-};
+typedef  HashSumValue<160> SHA1SumValue;
 
 class SHA1Summation
 {
diff --git a/apt-pkg/contrib/sha2.cc b/apt-pkg/contrib/sha2.cc
new file mode 100644
index 000000000..4604d3167
--- /dev/null
+++ b/apt-pkg/contrib/sha2.cc
@@ -0,0 +1,43 @@
+/*
+ * Cryptographic API.							{{{
+ *
+ * SHA-512, as specified in
+ * http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option) 
+ * any later version.
+ *
+ */									/*}}}*/
+
+#ifdef __GNUG__
+#pragma implementation "apt-pkg/sha2.h"
+#endif
+
+#include <apt-pkg/sha2.h>
+#include <apt-pkg/strutl.h>
+
+// SHA2Summation::AddFD - Add content of file into the checksum      /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool SHA2SummationBase::AddFD(int Fd,unsigned long Size){
+   unsigned char Buf[64 * 64];
+   int Res = 0;
+   int ToEOF = (Size == 0);
+   while (Size != 0 || ToEOF)
+   {
+      unsigned n = sizeof(Buf);
+      if (!ToEOF) n = min(Size,(unsigned long)n);
+      Res = read(Fd,Buf,n);
+      if (Res < 0 || (!ToEOF && (unsigned) Res != n)) // error, or short read
+         return false;
+      if (ToEOF && Res == 0) // EOF
+         break;
+      Size -= Res;
+      Add(Buf,Res);
+   }
+   return true;
+}
+                                                                       /*}}}*/
+
diff --git a/apt-pkg/contrib/sha2.h b/apt-pkg/contrib/sha2.h
new file mode 100644
index 000000000..bd5472527
--- /dev/null
+++ b/apt-pkg/contrib/sha2.h
@@ -0,0 +1,114 @@
+// -*- mode: cpp; mode: fold -*-
+// Description                                                          /*{{{*/
+// $Id: sha512.h,v 1.3 2001/05/07 05:05:47 jgg Exp $
+/* ######################################################################
+
+   SHA{512,256}SumValue - Storage for a SHA-{512,256} hash.
+   SHA{512,256}Summation - SHA-{512,256} Secure Hash Algorithm.
+   
+   This is a C++ interface to a set of SHA{512,256}Sum functions, that mirrors
+   the equivalent MD5 & SHA1 classes. 
+
+   ##################################################################### */
+                                                                        /*}}}*/
+#ifndef APTPKG_SHA2_H
+#define APTPKG_SHA2_H
+
+#include <string>
+#include <cstring>
+#include <algorithm>
+#include <stdint.h>
+
+#include "sha2_internal.h"
+#include "hashsum_template.h"
+
+using std::string;
+using std::min;
+
+class SHA512Summation;
+class SHA256Summation;
+
+typedef HashSumValue<512> SHA512SumValue;
+typedef HashSumValue<256> SHA256SumValue;
+
+class SHA2SummationBase
+{
+ protected:
+   bool Done;
+ public:
+   virtual bool Add(const unsigned char *inbuf,unsigned long inlen) = 0;
+   virtual bool AddFD(int Fd,unsigned long Size);
+
+   inline bool Add(const char *Data) 
+   {
+      return Add((unsigned char *)Data,strlen(Data));
+   };
+   inline bool Add(const unsigned char *Beg,const unsigned char *End) 
+   {
+      return Add(Beg,End-Beg);
+   };
+   void Result();
+};
+
+class SHA256Summation : public SHA2SummationBase
+{
+   SHA256_CTX ctx;
+   unsigned char Sum[32];
+
+   public:
+   virtual bool Add(const unsigned char *inbuf, unsigned long len)
+   {
+      if (Done) 
+         return false;
+      SHA256_Update(&ctx, inbuf, len);
+      return true;
+   };
+   SHA256SumValue Result()
+   {
+      if (!Done) {
+         SHA256_Final(Sum, &ctx);
+         Done = true;
+      }
+      SHA256SumValue res;
+      res.Set(Sum);
+      return res;
+   };
+   SHA256Summation() 
+   {
+      SHA256_Init(&ctx);
+      Done = false;
+   };
+};
+
+class SHA512Summation : public SHA2SummationBase
+{
+   SHA512_CTX ctx;
+   unsigned char Sum[64];
+
+   public:
+   virtual bool Add(const unsigned char *inbuf, unsigned long len)
+   {
+      if (Done) 
+         return false;
+      SHA512_Update(&ctx, inbuf, len);
+      return true;
+   };
+   SHA512SumValue Result()
+   {
+      if (!Done) {
+         SHA512_Final(Sum, &ctx);
+         Done = true;
+      }
+      SHA512SumValue res;
+      res.Set(Sum);
+      return res;
+   };
+   SHA512Summation()
+   {
+      SHA512_Init(&ctx);
+      Done = false;
+   };
+};
+
+
+#endif
diff --git a/apt-pkg/contrib/sha256.cc b/apt-pkg/contrib/sha256.cc
deleted file mode 100644
index e380c13ae..000000000
--- a/apt-pkg/contrib/sha256.cc
+++ /dev/null
@@ -1,424 +0,0 @@
-/*
- * Cryptographic API.							{{{
- *
- * SHA-256, as specified in
- * http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf
- *
- * SHA-256 code by Jean-Luc Cooke <jlcooke@certainkey.com>.
- *
- * Copyright (c) Jean-Luc Cooke <jlcooke@certainkey.com>
- * Copyright (c) Andrew McDonald <andrew@mcdonald.org.uk>
- * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
- *
- * Ported from the Linux kernel to Apt by Anthony Towns <ajt@debian.org>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 2 of the License, or (at your option) 
- * any later version.
- *
- */									/*}}}*/
-
-#ifdef __GNUG__
-#pragma implementation "apt-pkg/sha256.h"
-#endif
-
-
-#define SHA256_DIGEST_SIZE      32
-#define SHA256_HMAC_BLOCK_SIZE  64
-
-#define ror32(value,bits) (((value) >> (bits)) | ((value) << (32 - (bits))))
-
-#include <apt-pkg/sha256.h>
-#include <apt-pkg/strutl.h>
-#include <string.h>
-#include <unistd.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <arpa/inet.h>
-
-typedef uint32_t u32;
-typedef uint8_t  u8;
-
-static inline u32 Ch(u32 x, u32 y, u32 z)
-{
-        return z ^ (x & (y ^ z));
-}
-
-static inline u32 Maj(u32 x, u32 y, u32 z)
-{
-        return (x & y) | (z & (x | y));
-}
-
-#define e0(x)       (ror32(x, 2) ^ ror32(x,13) ^ ror32(x,22))
-#define e1(x)       (ror32(x, 6) ^ ror32(x,11) ^ ror32(x,25))
-#define s0(x)       (ror32(x, 7) ^ ror32(x,18) ^ (x >> 3))
-#define s1(x)       (ror32(x,17) ^ ror32(x,19) ^ (x >> 10))
-
-#define H0         0x6a09e667
-#define H1         0xbb67ae85
-#define H2         0x3c6ef372
-#define H3         0xa54ff53a
-#define H4         0x510e527f
-#define H5         0x9b05688c
-#define H6         0x1f83d9ab
-#define H7         0x5be0cd19
-
-static inline void LOAD_OP(int I, u32 *W, const u8 *input)		/*{{{*/
-{
-	W[I] = (  ((u32) input[I * 4 + 0] << 24)
-		| ((u32) input[I * 4 + 1] << 16)
-		| ((u32) input[I * 4 + 2] << 8)
-		| ((u32) input[I * 4 + 3]));
-}
-									/*}}}*/
-static inline void BLEND_OP(int I, u32 *W)
-{
-        W[I] = s1(W[I-2]) + W[I-7] + s0(W[I-15]) + W[I-16];
-}
-
-static void sha256_transform(u32 *state, const u8 *input)		/*{{{*/
-{
-        u32 a, b, c, d, e, f, g, h, t1, t2;
-        u32 W[64];
-        int i;
-
-        /* load the input */
-        for (i = 0; i < 16; i++)
-                LOAD_OP(i, W, input);
-
-        /* now blend */
-        for (i = 16; i < 64; i++)
-                BLEND_OP(i, W);
-    
-        /* load the state into our registers */
-        a=state[0];  b=state[1];  c=state[2];  d=state[3];
-        e=state[4];  f=state[5];  g=state[6];  h=state[7];
-
-        /* now iterate */
-        t1 = h + e1(e) + Ch(e,f,g) + 0x428a2f98 + W[ 0];
-        t2 = e0(a) + Maj(a,b,c);    d+=t1;    h=t1+t2;
-        t1 = g + e1(d) + Ch(d,e,f) + 0x71374491 + W[ 1];
-        t2 = e0(h) + Maj(h,a,b);    c+=t1;    g=t1+t2;
-        t1 = f + e1(c) + Ch(c,d,e) + 0xb5c0fbcf + W[ 2];
-        t2 = e0(g) + Maj(g,h,a);    b+=t1;    f=t1+t2;
-        t1 = e + e1(b) + Ch(b,c,d) + 0xe9b5dba5 + W[ 3];
-        t2 = e0(f) + Maj(f,g,h);    a+=t1;    e=t1+t2;
-        t1 = d + e1(a) + Ch(a,b,c) + 0x3956c25b + W[ 4];
-        t2 = e0(e) + Maj(e,f,g);    h+=t1;    d=t1+t2;
-        t1 = c + e1(h) + Ch(h,a,b) + 0x59f111f1 + W[ 5];
-        t2 = e0(d) + Maj(d,e,f);    g+=t1;    c=t1+t2;
-        t1 = b + e1(g) + Ch(g,h,a) + 0x923f82a4 + W[ 6];
-        t2 = e0(c) + Maj(c,d,e);    f+=t1;    b=t1+t2;
-        t1 = a + e1(f) + Ch(f,g,h) + 0xab1c5ed5 + W[ 7];
-        t2 = e0(b) + Maj(b,c,d);    e+=t1;    a=t1+t2;
-
-        t1 = h + e1(e) + Ch(e,f,g) + 0xd807aa98 + W[ 8];
-        t2 = e0(a) + Maj(a,b,c);    d+=t1;    h=t1+t2;
-        t1 = g + e1(d) + Ch(d,e,f) + 0x12835b01 + W[ 9];
-        t2 = e0(h) + Maj(h,a,b);    c+=t1;    g=t1+t2;
-        t1 = f + e1(c) + Ch(c,d,e) + 0x243185be + W[10];
-        t2 = e0(g) + Maj(g,h,a);    b+=t1;    f=t1+t2;
-        t1 = e + e1(b) + Ch(b,c,d) + 0x550c7dc3 + W[11];
-        t2 = e0(f) + Maj(f,g,h);    a+=t1;    e=t1+t2;
-        t1 = d + e1(a) + Ch(a,b,c) + 0x72be5d74 + W[12];
-        t2 = e0(e) + Maj(e,f,g);    h+=t1;    d=t1+t2;
-        t1 = c + e1(h) + Ch(h,a,b) + 0x80deb1fe + W[13];
-        t2 = e0(d) + Maj(d,e,f);    g+=t1;    c=t1+t2;
-        t1 = b + e1(g) + Ch(g,h,a) + 0x9bdc06a7 + W[14];
-        t2 = e0(c) + Maj(c,d,e);    f+=t1;    b=t1+t2;
-        t1 = a + e1(f) + Ch(f,g,h) + 0xc19bf174 + W[15];
-        t2 = e0(b) + Maj(b,c,d);    e+=t1;    a=t1+t2;
-
-        t1 = h + e1(e) + Ch(e,f,g) + 0xe49b69c1 + W[16];
-        t2 = e0(a) + Maj(a,b,c);    d+=t1;    h=t1+t2;
-        t1 = g + e1(d) + Ch(d,e,f) + 0xefbe4786 + W[17];
-        t2 = e0(h) + Maj(h,a,b);    c+=t1;    g=t1+t2;
-        t1 = f + e1(c) + Ch(c,d,e) + 0x0fc19dc6 + W[18];
-        t2 = e0(g) + Maj(g,h,a);    b+=t1;    f=t1+t2;
-        t1 = e + e1(b) + Ch(b,c,d) + 0x240ca1cc + W[19];
-        t2 = e0(f) + Maj(f,g,h);    a+=t1;    e=t1+t2;
-        t1 = d + e1(a) + Ch(a,b,c) + 0x2de92c6f + W[20];
-        t2 = e0(e) + Maj(e,f,g);    h+=t1;    d=t1+t2;
-        t1 = c + e1(h) + Ch(h,a,b) + 0x4a7484aa + W[21];
-        t2 = e0(d) + Maj(d,e,f);    g+=t1;    c=t1+t2;
-        t1 = b + e1(g) + Ch(g,h,a) + 0x5cb0a9dc + W[22];
-        t2 = e0(c) + Maj(c,d,e);    f+=t1;    b=t1+t2;
-        t1 = a + e1(f) + Ch(f,g,h) + 0x76f988da + W[23];
-        t2 = e0(b) + Maj(b,c,d);    e+=t1;    a=t1+t2;
-
-        t1 = h + e1(e) + Ch(e,f,g) + 0x983e5152 + W[24];
-        t2 = e0(a) + Maj(a,b,c);    d+=t1;    h=t1+t2;
-        t1 = g + e1(d) + Ch(d,e,f) + 0xa831c66d + W[25];
-        t2 = e0(h) + Maj(h,a,b);    c+=t1;    g=t1+t2;
-        t1 = f + e1(c) + Ch(c,d,e) + 0xb00327c8 + W[26];
-        t2 = e0(g) + Maj(g,h,a);    b+=t1;    f=t1+t2;
-        t1 = e + e1(b) + Ch(b,c,d) + 0xbf597fc7 + W[27];
-        t2 = e0(f) + Maj(f,g,h);    a+=t1;    e=t1+t2;
-        t1 = d + e1(a) + Ch(a,b,c) + 0xc6e00bf3 + W[28];
-        t2 = e0(e) + Maj(e,f,g);    h+=t1;    d=t1+t2;
-        t1 = c + e1(h) + Ch(h,a,b) + 0xd5a79147 + W[29];
-        t2 = e0(d) + Maj(d,e,f);    g+=t1;    c=t1+t2;
-        t1 = b + e1(g) + Ch(g,h,a) + 0x06ca6351 + W[30];
-        t2 = e0(c) + Maj(c,d,e);    f+=t1;    b=t1+t2;
-        t1 = a + e1(f) + Ch(f,g,h) + 0x14292967 + W[31];
-        t2 = e0(b) + Maj(b,c,d);    e+=t1;    a=t1+t2;
-
-        t1 = h + e1(e) + Ch(e,f,g) + 0x27b70a85 + W[32];
-        t2 = e0(a) + Maj(a,b,c);    d+=t1;    h=t1+t2;
-        t1 = g + e1(d) + Ch(d,e,f) + 0x2e1b2138 + W[33];
-        t2 = e0(h) + Maj(h,a,b);    c+=t1;    g=t1+t2;
-        t1 = f + e1(c) + Ch(c,d,e) + 0x4d2c6dfc + W[34];
-        t2 = e0(g) + Maj(g,h,a);    b+=t1;    f=t1+t2;
-        t1 = e + e1(b) + Ch(b,c,d) + 0x53380d13 + W[35];
-        t2 = e0(f) + Maj(f,g,h);    a+=t1;    e=t1+t2;
-        t1 = d + e1(a) + Ch(a,b,c) + 0x650a7354 + W[36];
-        t2 = e0(e) + Maj(e,f,g);    h+=t1;    d=t1+t2;
-        t1 = c + e1(h) + Ch(h,a,b) + 0x766a0abb + W[37];
-        t2 = e0(d) + Maj(d,e,f);    g+=t1;    c=t1+t2;
-        t1 = b + e1(g) + Ch(g,h,a) + 0x81c2c92e + W[38];
-        t2 = e0(c) + Maj(c,d,e);    f+=t1;    b=t1+t2;
-        t1 = a + e1(f) + Ch(f,g,h) + 0x92722c85 + W[39];
-        t2 = e0(b) + Maj(b,c,d);    e+=t1;    a=t1+t2;
-
-        t1 = h + e1(e) + Ch(e,f,g) + 0xa2bfe8a1 + W[40];
-        t2 = e0(a) + Maj(a,b,c);    d+=t1;    h=t1+t2;
-        t1 = g + e1(d) + Ch(d,e,f) + 0xa81a664b + W[41];
-        t2 = e0(h) + Maj(h,a,b);    c+=t1;    g=t1+t2;
-        t1 = f + e1(c) + Ch(c,d,e) + 0xc24b8b70 + W[42];
-        t2 = e0(g) + Maj(g,h,a);    b+=t1;    f=t1+t2;
-        t1 = e + e1(b) + Ch(b,c,d) + 0xc76c51a3 + W[43];
-        t2 = e0(f) + Maj(f,g,h);    a+=t1;    e=t1+t2;
-        t1 = d + e1(a) + Ch(a,b,c) + 0xd192e819 + W[44];
-        t2 = e0(e) + Maj(e,f,g);    h+=t1;    d=t1+t2;
-        t1 = c + e1(h) + Ch(h,a,b) + 0xd6990624 + W[45];
-        t2 = e0(d) + Maj(d,e,f);    g+=t1;    c=t1+t2;
-        t1 = b + e1(g) + Ch(g,h,a) + 0xf40e3585 + W[46];
-        t2 = e0(c) + Maj(c,d,e);    f+=t1;    b=t1+t2;
-        t1 = a + e1(f) + Ch(f,g,h) + 0x106aa070 + W[47];
-        t2 = e0(b) + Maj(b,c,d);    e+=t1;    a=t1+t2;
-
-        t1 = h + e1(e) + Ch(e,f,g) + 0x19a4c116 + W[48];
-        t2 = e0(a) + Maj(a,b,c);    d+=t1;    h=t1+t2;
-        t1 = g + e1(d) + Ch(d,e,f) + 0x1e376c08 + W[49];
-        t2 = e0(h) + Maj(h,a,b);    c+=t1;    g=t1+t2;
-        t1 = f + e1(c) + Ch(c,d,e) + 0x2748774c + W[50];
-        t2 = e0(g) + Maj(g,h,a);    b+=t1;    f=t1+t2;
-        t1 = e + e1(b) + Ch(b,c,d) + 0x34b0bcb5 + W[51];
-        t2 = e0(f) + Maj(f,g,h);    a+=t1;    e=t1+t2;
-        t1 = d + e1(a) + Ch(a,b,c) + 0x391c0cb3 + W[52];
-        t2 = e0(e) + Maj(e,f,g);    h+=t1;    d=t1+t2;
-        t1 = c + e1(h) + Ch(h,a,b) + 0x4ed8aa4a + W[53];
-        t2 = e0(d) + Maj(d,e,f);    g+=t1;    c=t1+t2;
-        t1 = b + e1(g) + Ch(g,h,a) + 0x5b9cca4f + W[54];
-        t2 = e0(c) + Maj(c,d,e);    f+=t1;    b=t1+t2;
-        t1 = a + e1(f) + Ch(f,g,h) + 0x682e6ff3 + W[55];
-        t2 = e0(b) + Maj(b,c,d);    e+=t1;    a=t1+t2;
-
-        t1 = h + e1(e) + Ch(e,f,g) + 0x748f82ee + W[56];
-        t2 = e0(a) + Maj(a,b,c);    d+=t1;    h=t1+t2;
-        t1 = g + e1(d) + Ch(d,e,f) + 0x78a5636f + W[57];
-        t2 = e0(h) + Maj(h,a,b);    c+=t1;    g=t1+t2;
-        t1 = f + e1(c) + Ch(c,d,e) + 0x84c87814 + W[58];
-        t2 = e0(g) + Maj(g,h,a);    b+=t1;    f=t1+t2;
-        t1 = e + e1(b) + Ch(b,c,d) + 0x8cc70208 + W[59];
-        t2 = e0(f) + Maj(f,g,h);    a+=t1;    e=t1+t2;
-        t1 = d + e1(a) + Ch(a,b,c) + 0x90befffa + W[60];
-        t2 = e0(e) + Maj(e,f,g);    h+=t1;    d=t1+t2;
-        t1 = c + e1(h) + Ch(h,a,b) + 0xa4506ceb + W[61];
-        t2 = e0(d) + Maj(d,e,f);    g+=t1;    c=t1+t2;
-        t1 = b + e1(g) + Ch(g,h,a) + 0xbef9a3f7 + W[62];
-        t2 = e0(c) + Maj(c,d,e);    f+=t1;    b=t1+t2;
-        t1 = a + e1(f) + Ch(f,g,h) + 0xc67178f2 + W[63];
-        t2 = e0(b) + Maj(b,c,d);    e+=t1;    a=t1+t2;
-
-        state[0] += a; state[1] += b; state[2] += c; state[3] += d;
-        state[4] += e; state[5] += f; state[6] += g; state[7] += h;
-
-        /* clear any sensitive info... */
-        a = b = c = d = e = f = g = h = t1 = t2 = 0;
-        memset(W, 0, 64 * sizeof(u32));
-}
-									/*}}}*/
-SHA256Summation::SHA256Summation()					/*{{{*/
-{
-        Sum.state[0] = H0;
-        Sum.state[1] = H1;
-        Sum.state[2] = H2;
-        Sum.state[3] = H3;
-        Sum.state[4] = H4;
-        Sum.state[5] = H5;
-        Sum.state[6] = H6;
-        Sum.state[7] = H7;
-        Sum.count[0] = Sum.count[1] = 0;
-        memset(Sum.buf, 0, sizeof(Sum.buf));
-        Done = false;
-}
-									/*}}}*/
-bool SHA256Summation::Add(const u8 *data, unsigned long len)		/*{{{*/
-{
-        struct sha256_ctx *sctx = &Sum;
-        unsigned int i, index, part_len;
-
-        if (Done) return false;
-
-        /* Compute number of bytes mod 128 */
-        index = (unsigned int)((sctx->count[0] >> 3) & 0x3f);
-
-        /* Update number of bits */
-        if ((sctx->count[0] += (len << 3)) < (len << 3)) {
-                sctx->count[1]++;
-                sctx->count[1] += (len >> 29);
-        }
-
-        part_len = 64 - index;
-
-        /* Transform as many times as possible. */
-        if (len >= part_len) {
-                memcpy(&sctx->buf[index], data, part_len);
-                sha256_transform(sctx->state, sctx->buf);
-
-                for (i = part_len; i + 63 < len; i += 64)
-                        sha256_transform(sctx->state, &data[i]);
-                index = 0;
-        } else {
-                i = 0;
-        }
-
-        /* Buffer remaining input */
-        memcpy(&sctx->buf[index], &data[i], len-i);
-
-        return true;
-}
-									/*}}}*/
-SHA256SumValue SHA256Summation::Result()				/*{{{*/
-{
-   struct sha256_ctx *sctx = &Sum;
-   if (!Done) {
-        u8 bits[8];
-        unsigned int index, pad_len, t;
-        static const u8 padding[64] = { 0x80, };
-
-        /* Save number of bits */
-        t = sctx->count[0];
-        bits[7] = t; t >>= 8;
-        bits[6] = t; t >>= 8;
-        bits[5] = t; t >>= 8;
-        bits[4] = t;
-        t = sctx->count[1];
-        bits[3] = t; t >>= 8;
-        bits[2] = t; t >>= 8;
-        bits[1] = t; t >>= 8;
-        bits[0] = t;
-
-        /* Pad out to 56 mod 64. */
-        index = (sctx->count[0] >> 3) & 0x3f;
-        pad_len = (index < 56) ? (56 - index) : ((64+56) - index);
-        Add(padding, pad_len);
-
-        /* Append length (before padding) */
-        Add(bits, 8);
-   }
-
-   Done = true;
-
-   /* Store state in digest */
-
-   SHA256SumValue res;
-   u8 *out = res.Sum;
-
-   int i, j;
-   unsigned int t;
-   for (i = j = 0; i < 8; i++, j += 4) {
-      t = sctx->state[i];
-      out[j+3] = t; t >>= 8;
-      out[j+2] = t; t >>= 8;
-      out[j+1] = t; t >>= 8;
-      out[j  ] = t;
-   }
-
-   return res;
-}
-									/*}}}*/
-// SHA256SumValue::SHA256SumValue - Constructs the sum from a string   /*{{{*/
-// ---------------------------------------------------------------------
-/* The string form of a SHA256 is a 64 character hex number */
-SHA256SumValue::SHA256SumValue(string Str)
-{
-   memset(Sum,0,sizeof(Sum));
-   Set(Str);
-}
-                                                                       /*}}}*/
-// SHA256SumValue::SHA256SumValue - Default constructor                /*{{{*/
-// ---------------------------------------------------------------------
-/* Sets the value to 0 */
-SHA256SumValue::SHA256SumValue()
-{
-   memset(Sum,0,sizeof(Sum));
-}
-                                                                       /*}}}*/
-// SHA256SumValue::Set - Set the sum from a string                     /*{{{*/
-// ---------------------------------------------------------------------
-/* Converts the hex string into a set of chars */
-bool SHA256SumValue::Set(string Str)
-{
-   return Hex2Num(Str,Sum,sizeof(Sum));
-}
-                                                                       /*}}}*/
-// SHA256SumValue::Value - Convert the number into a string            /*{{{*/
-// ---------------------------------------------------------------------
-/* Converts the set of chars into a hex string in lower case */
-string SHA256SumValue::Value() const
-{
-   char Conv[16] =
-      { '0','1','2','3','4','5','6','7','8','9','a','b',
-      'c','d','e','f'
-   };
-   char Result[65];
-   Result[64] = 0;
-
-   // Convert each char into two letters
-   int J = 0;
-   int I = 0;
-   for (; I != 64; J++,I += 2)
-   {
-      Result[I] = Conv[Sum[J] >> 4];
-      Result[I + 1] = Conv[Sum[J] & 0xF];
-   }
-
-   return string(Result);
-}
-									/*}}}*/
-// SHA256SumValue::operator == - Comparator                            /*{{{*/
-// ---------------------------------------------------------------------
-/* Call memcmp on the buffer */
-bool SHA256SumValue::operator == (const SHA256SumValue & rhs) const
-{
-   return memcmp(Sum,rhs.Sum,sizeof(Sum)) == 0;
-}
-                                                                       /*}}}*/
-// SHA256Summation::AddFD - Add content of file into the checksum      /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-bool SHA256Summation::AddFD(int Fd,unsigned long Size)
-{
-   unsigned char Buf[64 * 64];
-   int Res = 0;
-   int ToEOF = (Size == 0);
-   while (Size != 0 || ToEOF)
-   {
-      unsigned n = sizeof(Buf);
-      if (!ToEOF) n = min(Size,(unsigned long)n);
-      Res = read(Fd,Buf,n);
-      if (Res < 0 || (!ToEOF && (unsigned) Res != n)) // error, or short read
-         return false;
-      if (ToEOF && Res == 0) // EOF
-         break;
-      Size -= Res;
-      Add(Buf,Res);
-   }
-   return true;
-}
-                                                                       /*}}}*/
-
diff --git a/apt-pkg/contrib/sha256.h b/apt-pkg/contrib/sha256.h
index 5934b5641..fe2b30ac2 100644
--- a/apt-pkg/contrib/sha256.h
+++ b/apt-pkg/contrib/sha256.h
@@ -1,72 +1,8 @@
-// -*- mode: cpp; mode: fold -*-
-// Description                                                          /*{{{*/
-// $Id: sha1.h,v 1.3 2001/05/07 05:05:47 jgg Exp $
-/* ######################################################################
-
-   SHA256SumValue - Storage for a SHA-256 hash.
-   SHA256Summation - SHA-256 Secure Hash Algorithm.
-   
-   This is a C++ interface to a set of SHA256Sum functions, that mirrors
-   the equivalent MD5 & SHA1 classes. 
-
-   ##################################################################### */
-                                                                        /*}}}*/
 #ifndef APTPKG_SHA256_H
 #define APTPKG_SHA256_H
 
-#include <string>
-#include <cstring>
-#include <algorithm>
-#include <stdint.h>
-
-using std::string;
-using std::min;
-
-class SHA256Summation;
-
-class SHA256SumValue
-{
-   friend class SHA256Summation;
-   unsigned char Sum[32];
-   
-   public:
-
-   // Accessors
-   bool operator ==(const SHA256SumValue &rhs) const; 
-   string Value() const;
-   inline void Value(unsigned char S[32])
-         {for (int I = 0; I != sizeof(Sum); I++) S[I] = Sum[I];};
-   inline operator string() const {return Value();};
-   bool Set(string Str);
-   inline void Set(unsigned char S[32]) 
-         {for (int I = 0; I != sizeof(Sum); I++) Sum[I] = S[I];};
-
-   SHA256SumValue(string Str);
-   SHA256SumValue();
-};
-
-struct sha256_ctx {
-    uint32_t count[2];
-    uint32_t state[8];
-    uint8_t buf[128];
-};
-
-class SHA256Summation
-{
-   struct sha256_ctx Sum;
-
-   bool Done;
-
-   public:
+#include "sha2.h"
 
-   bool Add(const unsigned char *inbuf,unsigned long inlen);
-   inline bool Add(const char *Data) {return Add((unsigned char *)Data,strlen(Data));};
-   bool AddFD(int Fd,unsigned long Size);
-   inline bool Add(const unsigned char *Beg,const unsigned char *End) 
-                  {return Add(Beg,End-Beg);};
-   SHA256SumValue Result();
-   
-   SHA256Summation();
-};
+#warn "This header is deprecated, please include sha2.h instead"
 
 #endif
diff --git a/apt-pkg/contrib/sha2_internal.cc b/apt-pkg/contrib/sha2_internal.cc
new file mode 100644
index 000000000..10b82dec4
--- /dev/null
+++ b/apt-pkg/contrib/sha2_internal.cc
@@ -0,0 +1,1065 @@
+/*
+ * FILE:	sha2.c
+ * AUTHOR:	Aaron D. Gifford - http://www.aarongifford.com/
+ * 
+ * Copyright (c) 2000-2001, Aaron D. Gifford
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $Id: sha2.c,v 1.1 2001/11/08 00:01:51 adg Exp adg $
+ */
+
+#include <string.h>	/* memcpy()/memset() or bcopy()/bzero() */
+#include <assert.h>	/* assert() */
+#include "sha2_internal.h"
+
+/*
+ * ASSERT NOTE:
+ * Some sanity checking code is included using assert().  On my FreeBSD
+ * system, this additional code can be removed by compiling with NDEBUG
+ * defined.  Check your own systems manpage on assert() to see how to
+ * compile WITHOUT the sanity checking code on your system.
+ *
+ * UNROLLED TRANSFORM LOOP NOTE:
+ * You can define SHA2_UNROLL_TRANSFORM to use the unrolled transform
+ * loop version for the hash transform rounds (defined using macros
+ * later in this file).  Either define on the command line, for example:
+ *
+ *   cc -DSHA2_UNROLL_TRANSFORM -o sha2 sha2.c sha2prog.c
+ *
+ * or define below:
+ *
+ *   #define SHA2_UNROLL_TRANSFORM
+ *
+ */
+
+
+/*** SHA-256/384/512 Machine Architecture Definitions *****************/
+/*
+ * BYTE_ORDER NOTE:
+ *
+ * Please make sure that your system defines BYTE_ORDER.  If your
+ * architecture is little-endian, make sure it also defines
+ * LITTLE_ENDIAN and that the two (BYTE_ORDER and LITTLE_ENDIAN) are
+ * equivilent.
+ *
+ * If your system does not define the above, then you can do so by
+ * hand like this:
+ *
+ *   #define LITTLE_ENDIAN 1234
+ *   #define BIG_ENDIAN    4321
+ *
+ * And for little-endian machines, add:
+ *
+ *   #define BYTE_ORDER LITTLE_ENDIAN 
+ *
+ * Or for big-endian machines:
+ *
+ *   #define BYTE_ORDER BIG_ENDIAN
+ *
+ * The FreeBSD machine this was written on defines BYTE_ORDER
+ * appropriately by including <sys/types.h> (which in turn includes
+ * <machine/endian.h> where the appropriate definitions are actually
+ * made).
+ */
+#if !defined(BYTE_ORDER) || (BYTE_ORDER != LITTLE_ENDIAN && BYTE_ORDER != BIG_ENDIAN)
+#error Define BYTE_ORDER to be equal to either LITTLE_ENDIAN or BIG_ENDIAN
+#endif
+
+/*
+ * Define the followingsha2_* types to types of the correct length on
+ * the native archtecture.   Most BSD systems and Linux define u_intXX_t
+ * types.  Machines with very recent ANSI C headers, can use the
+ * uintXX_t definintions from inttypes.h by defining SHA2_USE_INTTYPES_H
+ * during compile or in the sha.h header file.
+ *
+ * Machines that support neither u_intXX_t nor inttypes.h's uintXX_t
+ * will need to define these three typedefs below (and the appropriate
+ * ones in sha.h too) by hand according to their system architecture.
+ *
+ * Thank you, Jun-ichiro itojun Hagino, for suggesting using u_intXX_t
+ * types and pointing out recent ANSI C support for uintXX_t in inttypes.h.
+ */
+#ifdef SHA2_USE_INTTYPES_H
+
+typedef uint8_t  sha2_byte;	/* Exactly 1 byte */
+typedef uint32_t sha2_word32;	/* Exactly 4 bytes */
+typedef uint64_t sha2_word64;	/* Exactly 8 bytes */
+
+#else /* SHA2_USE_INTTYPES_H */
+
+typedef u_int8_t  sha2_byte;	/* Exactly 1 byte */
+typedef u_int32_t sha2_word32;	/* Exactly 4 bytes */
+typedef u_int64_t sha2_word64;	/* Exactly 8 bytes */
+
+#endif /* SHA2_USE_INTTYPES_H */
+
+
+/*** SHA-256/384/512 Various Length Definitions ***********************/
+/* NOTE: Most of these are in sha2.h */
+#define SHA256_SHORT_BLOCK_LENGTH	(SHA256_BLOCK_LENGTH - 8)
+#define SHA384_SHORT_BLOCK_LENGTH	(SHA384_BLOCK_LENGTH - 16)
+#define SHA512_SHORT_BLOCK_LENGTH	(SHA512_BLOCK_LENGTH - 16)
+
+
+/*** ENDIAN REVERSAL MACROS *******************************************/
+#if BYTE_ORDER == LITTLE_ENDIAN
+#define REVERSE32(w,x)	{ \
+	sha2_word32 tmp = (w); \
+	tmp = (tmp >> 16) | (tmp << 16); \
+	(x) = ((tmp & 0xff00ff00UL) >> 8) | ((tmp & 0x00ff00ffUL) << 8); \
+}
+#define REVERSE64(w,x)	{ \
+	sha2_word64 tmp = (w); \
+	tmp = (tmp >> 32) | (tmp << 32); \
+	tmp = ((tmp & 0xff00ff00ff00ff00ULL) >> 8) | \
+	      ((tmp & 0x00ff00ff00ff00ffULL) << 8); \
+	(x) = ((tmp & 0xffff0000ffff0000ULL) >> 16) | \
+	      ((tmp & 0x0000ffff0000ffffULL) << 16); \
+}
+#endif /* BYTE_ORDER == LITTLE_ENDIAN */
+
+/*
+ * Macro for incrementally adding the unsigned 64-bit integer n to the
+ * unsigned 128-bit integer (represented using a two-element array of
+ * 64-bit words):
+ */
+#define ADDINC128(w,n)	{ \
+	(w)[0] += (sha2_word64)(n); \
+	if ((w)[0] < (n)) { \
+		(w)[1]++; \
+	} \
+}
+
+/*
+ * Macros for copying blocks of memory and for zeroing out ranges
+ * of memory.  Using these macros makes it easy to switch from
+ * using memset()/memcpy() and using bzero()/bcopy().
+ *
+ * Please define either SHA2_USE_MEMSET_MEMCPY or define
+ * SHA2_USE_BZERO_BCOPY depending on which function set you
+ * choose to use:
+ */
+#if !defined(SHA2_USE_MEMSET_MEMCPY) && !defined(SHA2_USE_BZERO_BCOPY)
+/* Default to memset()/memcpy() if no option is specified */
+#define	SHA2_USE_MEMSET_MEMCPY	1
+#endif
+#if defined(SHA2_USE_MEMSET_MEMCPY) && defined(SHA2_USE_BZERO_BCOPY)
+/* Abort with an error if BOTH options are defined */
+#error Define either SHA2_USE_MEMSET_MEMCPY or SHA2_USE_BZERO_BCOPY, not both!
+#endif
+
+#ifdef SHA2_USE_MEMSET_MEMCPY
+#define MEMSET_BZERO(p,l)	memset((p), 0, (l))
+#define MEMCPY_BCOPY(d,s,l)	memcpy((d), (s), (l))
+#endif
+#ifdef SHA2_USE_BZERO_BCOPY
+#define MEMSET_BZERO(p,l)	bzero((p), (l))
+#define MEMCPY_BCOPY(d,s,l)	bcopy((s), (d), (l))
+#endif
+
+
+/*** THE SIX LOGICAL FUNCTIONS ****************************************/
+/*
+ * Bit shifting and rotation (used by the six SHA-XYZ logical functions:
+ *
+ *   NOTE:  The naming of R and S appears backwards here (R is a SHIFT and
+ *   S is a ROTATION) because the SHA-256/384/512 description document
+ *   (see http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf) uses this
+ *   same "backwards" definition.
+ */
+/* Shift-right (used in SHA-256, SHA-384, and SHA-512): */
+#define R(b,x) 		((x) >> (b))
+/* 32-bit Rotate-right (used in SHA-256): */
+#define S32(b,x)	(((x) >> (b)) | ((x) << (32 - (b))))
+/* 64-bit Rotate-right (used in SHA-384 and SHA-512): */
+#define S64(b,x)	(((x) >> (b)) | ((x) << (64 - (b))))
+
+/* Two of six logical functions used in SHA-256, SHA-384, and SHA-512: */
+#define Ch(x,y,z)	(((x) & (y)) ^ ((~(x)) & (z)))
+#define Maj(x,y,z)	(((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
+
+/* Four of six logical functions used in SHA-256: */
+#define Sigma0_256(x)	(S32(2,  (x)) ^ S32(13, (x)) ^ S32(22, (x)))
+#define Sigma1_256(x)	(S32(6,  (x)) ^ S32(11, (x)) ^ S32(25, (x)))
+#define sigma0_256(x)	(S32(7,  (x)) ^ S32(18, (x)) ^ R(3 ,   (x)))
+#define sigma1_256(x)	(S32(17, (x)) ^ S32(19, (x)) ^ R(10,   (x)))
+
+/* Four of six logical functions used in SHA-384 and SHA-512: */
+#define Sigma0_512(x)	(S64(28, (x)) ^ S64(34, (x)) ^ S64(39, (x)))
+#define Sigma1_512(x)	(S64(14, (x)) ^ S64(18, (x)) ^ S64(41, (x)))
+#define sigma0_512(x)	(S64( 1, (x)) ^ S64( 8, (x)) ^ R( 7,   (x)))
+#define sigma1_512(x)	(S64(19, (x)) ^ S64(61, (x)) ^ R( 6,   (x)))
+
+/*** INTERNAL FUNCTION PROTOTYPES *************************************/
+/* NOTE: These should not be accessed directly from outside this
+ * library -- they are intended for private internal visibility/use
+ * only.
+ */
+void SHA512_Last(SHA512_CTX*);
+void SHA256_Transform(SHA256_CTX*, const sha2_word32*);
+void SHA512_Transform(SHA512_CTX*, const sha2_word64*);
+
+
+/*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/
+/* Hash constant words K for SHA-256: */
+const static sha2_word32 K256[64] = {
+	0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL,
+	0x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL,
+	0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL,
+	0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL, 0xc19bf174UL,
+	0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL,
+	0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL,
+	0x983e5152UL, 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL,
+	0xc6e00bf3UL, 0xd5a79147UL, 0x06ca6351UL, 0x14292967UL,
+	0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL, 0x53380d13UL,
+	0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL,
+	0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL,
+	0xd192e819UL, 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL,
+	0x19a4c116UL, 0x1e376c08UL, 0x2748774cUL, 0x34b0bcb5UL,
+	0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL, 0x682e6ff3UL,
+	0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
+	0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL
+};
+
+/* Initial hash value H for SHA-256: */
+const static sha2_word32 sha256_initial_hash_value[8] = {
+	0x6a09e667UL,
+	0xbb67ae85UL,
+	0x3c6ef372UL,
+	0xa54ff53aUL,
+	0x510e527fUL,
+	0x9b05688cUL,
+	0x1f83d9abUL,
+	0x5be0cd19UL
+};
+
+/* Hash constant words K for SHA-384 and SHA-512: */
+const static sha2_word64 K512[80] = {
+	0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL,
+	0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL,
+	0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL,
+	0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL,
+	0xd807aa98a3030242ULL, 0x12835b0145706fbeULL,
+	0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL,
+	0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL,
+	0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL,
+	0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL,
+	0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL,
+	0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL,
+	0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL,
+	0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL,
+	0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL,
+	0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL,
+	0x06ca6351e003826fULL, 0x142929670a0e6e70ULL,
+	0x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL,
+	0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL,
+	0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL,
+	0x81c2c92e47edaee6ULL, 0x92722c851482353bULL,
+	0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL,
+	0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL,
+	0xd192e819d6ef5218ULL, 0xd69906245565a910ULL,
+	0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL,
+	0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL,
+	0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL,
+	0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL,
+	0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL,
+	0x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL,
+	0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL,
+	0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL,
+	0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL,
+	0xca273eceea26619cULL, 0xd186b8c721c0c207ULL,
+	0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL,
+	0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL,
+	0x113f9804bef90daeULL, 0x1b710b35131c471bULL,
+	0x28db77f523047d84ULL, 0x32caab7b40c72493ULL,
+	0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL,
+	0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL,
+	0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL
+};
+
+/* Initial hash value H for SHA-384 */
+const static sha2_word64 sha384_initial_hash_value[8] = {
+	0xcbbb9d5dc1059ed8ULL,
+	0x629a292a367cd507ULL,
+	0x9159015a3070dd17ULL,
+	0x152fecd8f70e5939ULL,
+	0x67332667ffc00b31ULL,
+	0x8eb44a8768581511ULL,
+	0xdb0c2e0d64f98fa7ULL,
+	0x47b5481dbefa4fa4ULL
+};
+
+/* Initial hash value H for SHA-512 */
+const static sha2_word64 sha512_initial_hash_value[8] = {
+	0x6a09e667f3bcc908ULL,
+	0xbb67ae8584caa73bULL,
+	0x3c6ef372fe94f82bULL,
+	0xa54ff53a5f1d36f1ULL,
+	0x510e527fade682d1ULL,
+	0x9b05688c2b3e6c1fULL,
+	0x1f83d9abfb41bd6bULL,
+	0x5be0cd19137e2179ULL
+};
+
+/*
+ * Constant used by SHA256/384/512_End() functions for converting the
+ * digest to a readable hexadecimal character string:
+ */
+static const char *sha2_hex_digits = "0123456789abcdef";
+
+
+/*** SHA-256: *********************************************************/
+void SHA256_Init(SHA256_CTX* context) {
+	if (context == (SHA256_CTX*)0) {
+		return;
+	}
+	MEMCPY_BCOPY(context->state, sha256_initial_hash_value, SHA256_DIGEST_LENGTH);
+	MEMSET_BZERO(context->buffer, SHA256_BLOCK_LENGTH);
+	context->bitcount = 0;
+}
+
+#ifdef SHA2_UNROLL_TRANSFORM
+
+/* Unrolled SHA-256 round macros: */
+
+#if BYTE_ORDER == LITTLE_ENDIAN
+
+#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h)	\
+	REVERSE32(*data++, W256[j]); \
+	T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \
+             K256[j] + W256[j]; \
+	(d) += T1; \
+	(h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
+	j++
+
+
+#else /* BYTE_ORDER == LITTLE_ENDIAN */
+
+#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h)	\
+	T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \
+	     K256[j] + (W256[j] = *data++); \
+	(d) += T1; \
+	(h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
+	j++
+
+#endif /* BYTE_ORDER == LITTLE_ENDIAN */
+
+#define ROUND256(a,b,c,d,e,f,g,h)	\
+	s0 = W256[(j+1)&0x0f]; \
+	s0 = sigma0_256(s0); \
+	s1 = W256[(j+14)&0x0f]; \
+	s1 = sigma1_256(s1); \
+	T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + K256[j] + \
+	     (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0); \
+	(d) += T1; \
+	(h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
+	j++
+
+void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
+	sha2_word32	a, b, c, d, e, f, g, h, s0, s1;
+	sha2_word32	T1, *W256;
+	int		j;
+
+	W256 = (sha2_word32*)context->buffer;
+
+	/* Initialize registers with the prev. intermediate value */
+	a = context->state[0];
+	b = context->state[1];
+	c = context->state[2];
+	d = context->state[3];
+	e = context->state[4];
+	f = context->state[5];
+	g = context->state[6];
+	h = context->state[7];
+
+	j = 0;
+	do {
+		/* Rounds 0 to 15 (unrolled): */
+		ROUND256_0_TO_15(a,b,c,d,e,f,g,h);
+		ROUND256_0_TO_15(h,a,b,c,d,e,f,g);
+		ROUND256_0_TO_15(g,h,a,b,c,d,e,f);
+		ROUND256_0_TO_15(f,g,h,a,b,c,d,e);
+		ROUND256_0_TO_15(e,f,g,h,a,b,c,d);
+		ROUND256_0_TO_15(d,e,f,g,h,a,b,c);
+		ROUND256_0_TO_15(c,d,e,f,g,h,a,b);
+		ROUND256_0_TO_15(b,c,d,e,f,g,h,a);
+	} while (j < 16);
+
+	/* Now for the remaining rounds to 64: */
+	do {
+		ROUND256(a,b,c,d,e,f,g,h);
+		ROUND256(h,a,b,c,d,e,f,g);
+		ROUND256(g,h,a,b,c,d,e,f);
+		ROUND256(f,g,h,a,b,c,d,e);
+		ROUND256(e,f,g,h,a,b,c,d);
+		ROUND256(d,e,f,g,h,a,b,c);
+		ROUND256(c,d,e,f,g,h,a,b);
+		ROUND256(b,c,d,e,f,g,h,a);
+	} while (j < 64);
+
+	/* Compute the current intermediate hash value */
+	context->state[0] += a;
+	context->state[1] += b;
+	context->state[2] += c;
+	context->state[3] += d;
+	context->state[4] += e;
+	context->state[5] += f;
+	context->state[6] += g;
+	context->state[7] += h;
+
+	/* Clean up */
+	a = b = c = d = e = f = g = h = T1 = 0;
+}
+
+#else /* SHA2_UNROLL_TRANSFORM */
+
+void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
+	sha2_word32	a, b, c, d, e, f, g, h, s0, s1;
+	sha2_word32	T1, T2, *W256;
+	int		j;
+
+	W256 = (sha2_word32*)context->buffer;
+
+	/* Initialize registers with the prev. intermediate value */
+	a = context->state[0];
+	b = context->state[1];
+	c = context->state[2];
+	d = context->state[3];
+	e = context->state[4];
+	f = context->state[5];
+	g = context->state[6];
+	h = context->state[7];
+
+	j = 0;
+	do {
+#if BYTE_ORDER == LITTLE_ENDIAN
+		/* Copy data while converting to host byte order */
+		REVERSE32(*data++,W256[j]);
+		/* Apply the SHA-256 compression function to update a..h */
+		T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + W256[j];
+#else /* BYTE_ORDER == LITTLE_ENDIAN */
+		/* Apply the SHA-256 compression function to update a..h with copy */
+		T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + (W256[j] = *data++);
+#endif /* BYTE_ORDER == LITTLE_ENDIAN */
+		T2 = Sigma0_256(a) + Maj(a, b, c);
+		h = g;
+		g = f;
+		f = e;
+		e = d + T1;
+		d = c;
+		c = b;
+		b = a;
+		a = T1 + T2;
+
+		j++;
+	} while (j < 16);
+
+	do {
+		/* Part of the message block expansion: */
+		s0 = W256[(j+1)&0x0f];
+		s0 = sigma0_256(s0);
+		s1 = W256[(j+14)&0x0f];	
+		s1 = sigma1_256(s1);
+
+		/* Apply the SHA-256 compression function to update a..h */
+		T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + 
+		     (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0);
+		T2 = Sigma0_256(a) + Maj(a, b, c);
+		h = g;
+		g = f;
+		f = e;
+		e = d + T1;
+		d = c;
+		c = b;
+		b = a;
+		a = T1 + T2;
+
+		j++;
+	} while (j < 64);
+
+	/* Compute the current intermediate hash value */
+	context->state[0] += a;
+	context->state[1] += b;
+	context->state[2] += c;
+	context->state[3] += d;
+	context->state[4] += e;
+	context->state[5] += f;
+	context->state[6] += g;
+	context->state[7] += h;
+
+	/* Clean up */
+	a = b = c = d = e = f = g = h = T1 = T2 = 0;
+}
+
+#endif /* SHA2_UNROLL_TRANSFORM */
+
+void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {
+	unsigned int	freespace, usedspace;
+
+	if (len == 0) {
+		/* Calling with no data is valid - we do nothing */
+		return;
+	}
+
+	/* Sanity check: */
+	assert(context != (SHA256_CTX*)0 && data != (sha2_byte*)0);
+
+	usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
+	if (usedspace > 0) {
+		/* Calculate how much free space is available in the buffer */
+		freespace = SHA256_BLOCK_LENGTH - usedspace;
+
+		if (len >= freespace) {
+			/* Fill the buffer completely and process it */
+			MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace);
+			context->bitcount += freespace << 3;
+			len -= freespace;
+			data += freespace;
+			SHA256_Transform(context, (sha2_word32*)context->buffer);
+		} else {
+			/* The buffer is not yet full */
+			MEMCPY_BCOPY(&context->buffer[usedspace], data, len);
+			context->bitcount += len << 3;
+			/* Clean up: */
+			usedspace = freespace = 0;
+			return;
+		}
+	}
+	while (len >= SHA256_BLOCK_LENGTH) {
+		/* Process as many complete blocks as we can */
+		SHA256_Transform(context, (sha2_word32*)data);
+		context->bitcount += SHA256_BLOCK_LENGTH << 3;
+		len -= SHA256_BLOCK_LENGTH;
+		data += SHA256_BLOCK_LENGTH;
+	}
+	if (len > 0) {
+		/* There's left-overs, so save 'em */
+		MEMCPY_BCOPY(context->buffer, data, len);
+		context->bitcount += len << 3;
+	}
+	/* Clean up: */
+	usedspace = freespace = 0;
+}
+
+void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {
+	sha2_word32	*d = (sha2_word32*)digest;
+	unsigned int	usedspace;
+
+	/* Sanity check: */
+	assert(context != (SHA256_CTX*)0);
+
+	/* If no digest buffer is passed, we don't bother doing this: */
+	if (digest != (sha2_byte*)0) {
+		usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
+#if BYTE_ORDER == LITTLE_ENDIAN
+		/* Convert FROM host byte order */
+		REVERSE64(context->bitcount,context->bitcount);
+#endif
+		if (usedspace > 0) {
+			/* Begin padding with a 1 bit: */
+			context->buffer[usedspace++] = 0x80;
+
+			if (usedspace <= SHA256_SHORT_BLOCK_LENGTH) {
+				/* Set-up for the last transform: */
+				MEMSET_BZERO(&context->buffer[usedspace], SHA256_SHORT_BLOCK_LENGTH - usedspace);
+			} else {
+				if (usedspace < SHA256_BLOCK_LENGTH) {
+					MEMSET_BZERO(&context->buffer[usedspace], SHA256_BLOCK_LENGTH - usedspace);
+				}
+				/* Do second-to-last transform: */
+				SHA256_Transform(context, (sha2_word32*)context->buffer);
+
+				/* And set-up for the last transform: */
+				MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LENGTH);
+			}
+		} else {
+			/* Set-up for the last transform: */
+			MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LENGTH);
+
+			/* Begin padding with a 1 bit: */
+			*context->buffer = 0x80;
+		}
+		/* Set the bit count: */
+		*(sha2_word64*)&context->buffer[SHA256_SHORT_BLOCK_LENGTH] = context->bitcount;
+
+		/* Final transform: */
+		SHA256_Transform(context, (sha2_word32*)context->buffer);
+
+#if BYTE_ORDER == LITTLE_ENDIAN
+		{
+			/* Convert TO host byte order */
+			int	j;
+			for (j = 0; j < 8; j++) {
+				REVERSE32(context->state[j],context->state[j]);
+				*d++ = context->state[j];
+			}
+		}
+#else
+		MEMCPY_BCOPY(d, context->state, SHA256_DIGEST_LENGTH);
+#endif
+	}
+
+	/* Clean up state data: */
+	MEMSET_BZERO(context, sizeof(context));
+	usedspace = 0;
+}
+
+char *SHA256_End(SHA256_CTX* context, char buffer[]) {
+	sha2_byte	digest[SHA256_DIGEST_LENGTH], *d = digest;
+	int		i;
+
+	/* Sanity check: */
+	assert(context != (SHA256_CTX*)0);
+
+	if (buffer != (char*)0) {
+		SHA256_Final(digest, context);
+
+		for (i = 0; i < SHA256_DIGEST_LENGTH; i++) {
+			*buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
+			*buffer++ = sha2_hex_digits[*d & 0x0f];
+			d++;
+		}
+		*buffer = (char)0;
+	} else {
+		MEMSET_BZERO(context, sizeof(context));
+	}
+	MEMSET_BZERO(digest, SHA256_DIGEST_LENGTH);
+	return buffer;
+}
+
+char* SHA256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIGEST_STRING_LENGTH]) {
+	SHA256_CTX	context;
+
+	SHA256_Init(&context);
+	SHA256_Update(&context, data, len);
+	return SHA256_End(&context, digest);
+}
+
+
+/*** SHA-512: *********************************************************/
+void SHA512_Init(SHA512_CTX* context) {
+	if (context == (SHA512_CTX*)0) {
+		return;
+	}
+	MEMCPY_BCOPY(context->state, sha512_initial_hash_value, SHA512_DIGEST_LENGTH);
+	MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH);
+	context->bitcount[0] = context->bitcount[1] =  0;
+}
+
+#ifdef SHA2_UNROLL_TRANSFORM
+
+/* Unrolled SHA-512 round macros: */
+#if BYTE_ORDER == LITTLE_ENDIAN
+
+#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h)	\
+	REVERSE64(*data++, W512[j]); \
+	T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \
+             K512[j] + W512[j]; \
+	(d) += T1, \
+	(h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)), \
+	j++
+
+
+#else /* BYTE_ORDER == LITTLE_ENDIAN */
+
+#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h)	\
+	T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \
+             K512[j] + (W512[j] = *data++); \
+	(d) += T1; \
+	(h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
+	j++
+
+#endif /* BYTE_ORDER == LITTLE_ENDIAN */
+
+#define ROUND512(a,b,c,d,e,f,g,h)	\
+	s0 = W512[(j+1)&0x0f]; \
+	s0 = sigma0_512(s0); \
+	s1 = W512[(j+14)&0x0f]; \
+	s1 = sigma1_512(s1); \
+	T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + K512[j] + \
+             (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0); \
+	(d) += T1; \
+	(h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
+	j++
+
+void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
+	sha2_word64	a, b, c, d, e, f, g, h, s0, s1;
+	sha2_word64	T1, *W512 = (sha2_word64*)context->buffer;
+	int		j;
+
+	/* Initialize registers with the prev. intermediate value */
+	a = context->state[0];
+	b = context->state[1];
+	c = context->state[2];
+	d = context->state[3];
+	e = context->state[4];
+	f = context->state[5];
+	g = context->state[6];
+	h = context->state[7];
+
+	j = 0;
+	do {
+		ROUND512_0_TO_15(a,b,c,d,e,f,g,h);
+		ROUND512_0_TO_15(h,a,b,c,d,e,f,g);
+		ROUND512_0_TO_15(g,h,a,b,c,d,e,f);
+		ROUND512_0_TO_15(f,g,h,a,b,c,d,e);
+		ROUND512_0_TO_15(e,f,g,h,a,b,c,d);
+		ROUND512_0_TO_15(d,e,f,g,h,a,b,c);
+		ROUND512_0_TO_15(c,d,e,f,g,h,a,b);
+		ROUND512_0_TO_15(b,c,d,e,f,g,h,a);
+	} while (j < 16);
+
+	/* Now for the remaining rounds up to 79: */
+	do {
+		ROUND512(a,b,c,d,e,f,g,h);
+		ROUND512(h,a,b,c,d,e,f,g);
+		ROUND512(g,h,a,b,c,d,e,f);
+		ROUND512(f,g,h,a,b,c,d,e);
+		ROUND512(e,f,g,h,a,b,c,d);
+		ROUND512(d,e,f,g,h,a,b,c);
+		ROUND512(c,d,e,f,g,h,a,b);
+		ROUND512(b,c,d,e,f,g,h,a);
+	} while (j < 80);
+
+	/* Compute the current intermediate hash value */
+	context->state[0] += a;
+	context->state[1] += b;
+	context->state[2] += c;
+	context->state[3] += d;
+	context->state[4] += e;
+	context->state[5] += f;
+	context->state[6] += g;
+	context->state[7] += h;
+
+	/* Clean up */
+	a = b = c = d = e = f = g = h = T1 = 0;
+}
+
+#else /* SHA2_UNROLL_TRANSFORM */
+
+void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
+	sha2_word64	a, b, c, d, e, f, g, h, s0, s1;
+	sha2_word64	T1, T2, *W512 = (sha2_word64*)context->buffer;
+	int		j;
+
+	/* Initialize registers with the prev. intermediate value */
+	a = context->state[0];
+	b = context->state[1];
+	c = context->state[2];
+	d = context->state[3];
+	e = context->state[4];
+	f = context->state[5];
+	g = context->state[6];
+	h = context->state[7];
+
+	j = 0;
+	do {
+#if BYTE_ORDER == LITTLE_ENDIAN
+		/* Convert TO host byte order */
+		REVERSE64(*data++, W512[j]);
+		/* Apply the SHA-512 compression function to update a..h */
+		T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + W512[j];
+#else /* BYTE_ORDER == LITTLE_ENDIAN */
+		/* Apply the SHA-512 compression function to update a..h with copy */
+		T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + (W512[j] = *data++);
+#endif /* BYTE_ORDER == LITTLE_ENDIAN */
+		T2 = Sigma0_512(a) + Maj(a, b, c);
+		h = g;
+		g = f;
+		f = e;
+		e = d + T1;
+		d = c;
+		c = b;
+		b = a;
+		a = T1 + T2;
+
+		j++;
+	} while (j < 16);
+
+	do {
+		/* Part of the message block expansion: */
+		s0 = W512[(j+1)&0x0f];
+		s0 = sigma0_512(s0);
+		s1 = W512[(j+14)&0x0f];
+		s1 =  sigma1_512(s1);
+
+		/* Apply the SHA-512 compression function to update a..h */
+		T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] +
+		     (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0);
+		T2 = Sigma0_512(a) + Maj(a, b, c);
+		h = g;
+		g = f;
+		f = e;
+		e = d + T1;
+		d = c;
+		c = b;
+		b = a;
+		a = T1 + T2;
+
+		j++;
+	} while (j < 80);
+
+	/* Compute the current intermediate hash value */
+	context->state[0] += a;
+	context->state[1] += b;
+	context->state[2] += c;
+	context->state[3] += d;
+	context->state[4] += e;
+	context->state[5] += f;
+	context->state[6] += g;
+	context->state[7] += h;
+
+	/* Clean up */
+	a = b = c = d = e = f = g = h = T1 = T2 = 0;
+}
+
+#endif /* SHA2_UNROLL_TRANSFORM */
+
+void SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
+	unsigned int	freespace, usedspace;
+
+	if (len == 0) {
+		/* Calling with no data is valid - we do nothing */
+		return;
+	}
+
+	/* Sanity check: */
+	assert(context != (SHA512_CTX*)0 && data != (sha2_byte*)0);
+
+	usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
+	if (usedspace > 0) {
+		/* Calculate how much free space is available in the buffer */
+		freespace = SHA512_BLOCK_LENGTH - usedspace;
+
+		if (len >= freespace) {
+			/* Fill the buffer completely and process it */
+			MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace);
+			ADDINC128(context->bitcount, freespace << 3);
+			len -= freespace;
+			data += freespace;
+			SHA512_Transform(context, (sha2_word64*)context->buffer);
+		} else {
+			/* The buffer is not yet full */
+			MEMCPY_BCOPY(&context->buffer[usedspace], data, len);
+			ADDINC128(context->bitcount, len << 3);
+			/* Clean up: */
+			usedspace = freespace = 0;
+			return;
+		}
+	}
+	while (len >= SHA512_BLOCK_LENGTH) {
+		/* Process as many complete blocks as we can */
+		SHA512_Transform(context, (sha2_word64*)data);
+		ADDINC128(context->bitcount, SHA512_BLOCK_LENGTH << 3);
+		len -= SHA512_BLOCK_LENGTH;
+		data += SHA512_BLOCK_LENGTH;
+	}
+	if (len > 0) {
+		/* There's left-overs, so save 'em */
+		MEMCPY_BCOPY(context->buffer, data, len);
+		ADDINC128(context->bitcount, len << 3);
+	}
+	/* Clean up: */
+	usedspace = freespace = 0;
+}
+
+void SHA512_Last(SHA512_CTX* context) {
+	unsigned int	usedspace;
+
+	usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	/* Convert FROM host byte order */
+	REVERSE64(context->bitcount[0],context->bitcount[0]);
+	REVERSE64(context->bitcount[1],context->bitcount[1]);
+#endif
+	if (usedspace > 0) {
+		/* Begin padding with a 1 bit: */
+		context->buffer[usedspace++] = 0x80;
+
+		if (usedspace <= SHA512_SHORT_BLOCK_LENGTH) {
+			/* Set-up for the last transform: */
+			MEMSET_BZERO(&context->buffer[usedspace], SHA512_SHORT_BLOCK_LENGTH - usedspace);
+		} else {
+			if (usedspace < SHA512_BLOCK_LENGTH) {
+				MEMSET_BZERO(&context->buffer[usedspace], SHA512_BLOCK_LENGTH - usedspace);
+			}
+			/* Do second-to-last transform: */
+			SHA512_Transform(context, (sha2_word64*)context->buffer);
+
+			/* And set-up for the last transform: */
+			MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH - 2);
+		}
+	} else {
+		/* Prepare for final transform: */
+		MEMSET_BZERO(context->buffer, SHA512_SHORT_BLOCK_LENGTH);
+
+		/* Begin padding with a 1 bit: */
+		*context->buffer = 0x80;
+	}
+	/* Store the length of input data (in bits): */
+	*(sha2_word64*)&context->buffer[SHA512_SHORT_BLOCK_LENGTH] = context->bitcount[1];
+	*(sha2_word64*)&context->buffer[SHA512_SHORT_BLOCK_LENGTH+8] = context->bitcount[0];
+
+	/* Final transform: */
+	SHA512_Transform(context, (sha2_word64*)context->buffer);
+}
+
+void SHA512_Final(sha2_byte digest[], SHA512_CTX* context) {
+	sha2_word64	*d = (sha2_word64*)digest;
+
+	/* Sanity check: */
+	assert(context != (SHA512_CTX*)0);
+
+	/* If no digest buffer is passed, we don't bother doing this: */
+	if (digest != (sha2_byte*)0) {
+		SHA512_Last(context);
+
+		/* Save the hash data for output: */
+#if BYTE_ORDER == LITTLE_ENDIAN
+		{
+			/* Convert TO host byte order */
+			int	j;
+			for (j = 0; j < 8; j++) {
+				REVERSE64(context->state[j],context->state[j]);
+				*d++ = context->state[j];
+			}
+		}
+#else
+		MEMCPY_BCOPY(d, context->state, SHA512_DIGEST_LENGTH);
+#endif
+	}
+
+	/* Zero out state data */
+	MEMSET_BZERO(context, sizeof(context));
+}
+
+char *SHA512_End(SHA512_CTX* context, char buffer[]) {
+	sha2_byte	digest[SHA512_DIGEST_LENGTH], *d = digest;
+	int		i;
+
+	/* Sanity check: */
+	assert(context != (SHA512_CTX*)0);
+
+	if (buffer != (char*)0) {
+		SHA512_Final(digest, context);
+
+		for (i = 0; i < SHA512_DIGEST_LENGTH; i++) {
+			*buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
+			*buffer++ = sha2_hex_digits[*d & 0x0f];
+			d++;
+		}
+		*buffer = (char)0;
+	} else {
+		MEMSET_BZERO(context, sizeof(context));
+	}
+	MEMSET_BZERO(digest, SHA512_DIGEST_LENGTH);
+	return buffer;
+}
+
+char* SHA512_Data(const sha2_byte* data, size_t len, char digest[SHA512_DIGEST_STRING_LENGTH]) {
+	SHA512_CTX	context;
+
+	SHA512_Init(&context);
+	SHA512_Update(&context, data, len);
+	return SHA512_End(&context, digest);
+}
+
+
+/*** SHA-384: *********************************************************/
+void SHA384_Init(SHA384_CTX* context) {
+	if (context == (SHA384_CTX*)0) {
+		return;
+	}
+	MEMCPY_BCOPY(context->state, sha384_initial_hash_value, SHA512_DIGEST_LENGTH);
+	MEMSET_BZERO(context->buffer, SHA384_BLOCK_LENGTH);
+	context->bitcount[0] = context->bitcount[1] = 0;
+}
+
+void SHA384_Update(SHA384_CTX* context, const sha2_byte* data, size_t len) {
+	SHA512_Update((SHA512_CTX*)context, data, len);
+}
+
+void SHA384_Final(sha2_byte digest[], SHA384_CTX* context) {
+	sha2_word64	*d = (sha2_word64*)digest;
+
+	/* Sanity check: */
+	assert(context != (SHA384_CTX*)0);
+
+	/* If no digest buffer is passed, we don't bother doing this: */
+	if (digest != (sha2_byte*)0) {
+		SHA512_Last((SHA512_CTX*)context);
+
+		/* Save the hash data for output: */
+#if BYTE_ORDER == LITTLE_ENDIAN
+		{
+			/* Convert TO host byte order */
+			int	j;
+			for (j = 0; j < 6; j++) {
+				REVERSE64(context->state[j],context->state[j]);
+				*d++ = context->state[j];
+			}
+		}
+#else
+		MEMCPY_BCOPY(d, context->state, SHA384_DIGEST_LENGTH);
+#endif
+	}
+
+	/* Zero out state data */
+	MEMSET_BZERO(context, sizeof(context));
+}
+
+char *SHA384_End(SHA384_CTX* context, char buffer[]) {
+	sha2_byte	digest[SHA384_DIGEST_LENGTH], *d = digest;
+	int		i;
+
+	/* Sanity check: */
+	assert(context != (SHA384_CTX*)0);
+
+	if (buffer != (char*)0) {
+		SHA384_Final(digest, context);
+
+		for (i = 0; i < SHA384_DIGEST_LENGTH; i++) {
+			*buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
+			*buffer++ = sha2_hex_digits[*d & 0x0f];
+			d++;
+		}
+		*buffer = (char)0;
+	} else {
+		MEMSET_BZERO(context, sizeof(context));
+	}
+	MEMSET_BZERO(digest, SHA384_DIGEST_LENGTH);
+	return buffer;
+}
+
+char* SHA384_Data(const sha2_byte* data, size_t len, char digest[SHA384_DIGEST_STRING_LENGTH]) {
+	SHA384_CTX	context;
+
+	SHA384_Init(&context);
+	SHA384_Update(&context, data, len);
+	return SHA384_End(&context, digest);
+}
+
diff --git a/apt-pkg/contrib/sha2_internal.h b/apt-pkg/contrib/sha2_internal.h
new file mode 100644
index 000000000..bf759ad45
--- /dev/null
+++ b/apt-pkg/contrib/sha2_internal.h
@@ -0,0 +1,197 @@
+/*
+ * FILE:	sha2.h
+ * AUTHOR:	Aaron D. Gifford - http://www.aarongifford.com/
+ * 
+ * Copyright (c) 2000-2001, Aaron D. Gifford
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $Id: sha2.h,v 1.1 2001/11/08 00:02:01 adg Exp adg $
+ */
+
+#ifndef __SHA2_H__
+#define __SHA2_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*
+ * Import u_intXX_t size_t type definitions from system headers.  You
+ * may need to change this, or define these things yourself in this
+ * file.
+ */
+#include <sys/types.h>
+
+#ifdef SHA2_USE_INTTYPES_H
+
+#include <inttypes.h>
+
+#endif /* SHA2_USE_INTTYPES_H */
+
+
+/*** SHA-256/384/512 Various Length Definitions ***********************/
+#define SHA256_BLOCK_LENGTH		64
+#define SHA256_DIGEST_LENGTH		32
+#define SHA256_DIGEST_STRING_LENGTH	(SHA256_DIGEST_LENGTH * 2 + 1)
+#define SHA384_BLOCK_LENGTH		128
+#define SHA384_DIGEST_LENGTH		48
+#define SHA384_DIGEST_STRING_LENGTH	(SHA384_DIGEST_LENGTH * 2 + 1)
+#define SHA512_BLOCK_LENGTH		128
+#define SHA512_DIGEST_LENGTH		64
+#define SHA512_DIGEST_STRING_LENGTH	(SHA512_DIGEST_LENGTH * 2 + 1)
+
+
+/*** SHA-256/384/512 Context Structures *******************************/
+/* NOTE: If your architecture does not define either u_intXX_t types or
+ * uintXX_t (from inttypes.h), you may need to define things by hand
+ * for your system:
+ */
+#if 0
+typedef unsigned char u_int8_t;		/* 1-byte  (8-bits)  */
+typedef unsigned int u_int32_t;		/* 4-bytes (32-bits) */
+typedef unsigned long long u_int64_t;	/* 8-bytes (64-bits) */
+#endif
+/*
+ * Most BSD systems already define u_intXX_t types, as does Linux.
+ * Some systems, however, like Compaq's Tru64 Unix instead can use
+ * uintXX_t types defined by very recent ANSI C standards and included
+ * in the file:
+ *
+ *   #include <inttypes.h>
+ *
+ * If you choose to use <inttypes.h> then please define: 
+ *
+ *   #define SHA2_USE_INTTYPES_H
+ *
+ * Or on the command line during compile:
+ *
+ *   cc -DSHA2_USE_INTTYPES_H ...
+ */
+#ifdef SHA2_USE_INTTYPES_H
+
+typedef struct _SHA256_CTX {
+	uint32_t	state[8];
+	uint64_t	bitcount;
+	uint8_t	buffer[SHA256_BLOCK_LENGTH];
+} SHA256_CTX;
+typedef struct _SHA512_CTX {
+	uint64_t	state[8];
+	uint64_t	bitcount[2];
+	uint8_t	buffer[SHA512_BLOCK_LENGTH];
+} SHA512_CTX;
+
+#else /* SHA2_USE_INTTYPES_H */
+
+typedef struct _SHA256_CTX {
+	u_int32_t	state[8];
+	u_int64_t	bitcount;
+	u_int8_t	buffer[SHA256_BLOCK_LENGTH];
+} SHA256_CTX;
+typedef struct _SHA512_CTX {
+	u_int64_t	state[8];
+	u_int64_t	bitcount[2];
+	u_int8_t	buffer[SHA512_BLOCK_LENGTH];
+} SHA512_CTX;
+
+#endif /* SHA2_USE_INTTYPES_H */
+
+typedef SHA512_CTX SHA384_CTX;
+
+
+/*** SHA-256/384/512 Function Prototypes ******************************/
+#ifndef NOPROTO
+#ifdef SHA2_USE_INTTYPES_H
+
+void SHA256_Init(SHA256_CTX *);
+void SHA256_Update(SHA256_CTX*, const uint8_t*, size_t);
+void SHA256_Final(uint8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
+char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
+char* SHA256_Data(const uint8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
+
+void SHA384_Init(SHA384_CTX*);
+void SHA384_Update(SHA384_CTX*, const uint8_t*, size_t);
+void SHA384_Final(uint8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
+char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
+char* SHA384_Data(const uint8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
+
+void SHA512_Init(SHA512_CTX*);
+void SHA512_Update(SHA512_CTX*, const uint8_t*, size_t);
+void SHA512_Final(uint8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
+char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
+char* SHA512_Data(const uint8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
+
+#else /* SHA2_USE_INTTYPES_H */
+
+void SHA256_Init(SHA256_CTX *);
+void SHA256_Update(SHA256_CTX*, const u_int8_t*, size_t);
+void SHA256_Final(u_int8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
+char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
+char* SHA256_Data(const u_int8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
+
+void SHA384_Init(SHA384_CTX*);
+void SHA384_Update(SHA384_CTX*, const u_int8_t*, size_t);
+void SHA384_Final(u_int8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
+char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
+char* SHA384_Data(const u_int8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
+
+void SHA512_Init(SHA512_CTX*);
+void SHA512_Update(SHA512_CTX*, const u_int8_t*, size_t);
+void SHA512_Final(u_int8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
+char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
+char* SHA512_Data(const u_int8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
+
+#endif /* SHA2_USE_INTTYPES_H */
+
+#else /* NOPROTO */
+
+void SHA256_Init();
+void SHA256_Update();
+void SHA256_Final();
+char* SHA256_End();
+char* SHA256_Data();
+
+void SHA384_Init();
+void SHA384_Update();
+void SHA384_Final();
+char* SHA384_End();
+char* SHA384_Data();
+
+void SHA512_Init();
+void SHA512_Update();
+void SHA512_Final();
+char* SHA512_End();
+char* SHA512_Data();
+
+#endif /* NOPROTO */
+
+#ifdef	__cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __SHA2_H__ */
+
diff --git a/apt-pkg/deb/debindexfile.cc b/apt-pkg/deb/debindexfile.cc
index 1e8c04033..c9e7f1176 100644
--- a/apt-pkg/deb/debindexfile.cc
+++ b/apt-pkg/deb/debindexfile.cc
@@ -423,12 +423,10 @@ string debTranslationsIndex::IndexURI(const char *Type) const
 /* */
 bool debTranslationsIndex::GetIndexes(pkgAcquire *Owner) const
 {
-   if (TranslationsAvailable()) {
-     string const TranslationFile = string("Translation-").append(Language);
-     new pkgAcqIndexTrans(Owner, IndexURI(Language),
-			  Info(TranslationFile.c_str()),
-			  TranslationFile);
-   }
+   string const TranslationFile = string("Translation-").append(Language);
+   new pkgAcqIndexTrans(Owner, IndexURI(Language),
+                        Info(TranslationFile.c_str()),
+                        TranslationFile);
 
    return true;
 }
@@ -468,9 +466,6 @@ string debTranslationsIndex::Info(const char *Type) const
 									/*}}}*/
 bool debTranslationsIndex::HasPackages() const				/*{{{*/
 {
-   if(!TranslationsAvailable())
-      return false;
-   
    return FileExists(IndexFile(Language));
 }
 									/*}}}*/
@@ -510,7 +505,7 @@ bool debTranslationsIndex::Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const
 {
    // Check the translation file, if in use
    string TranslationFile = IndexFile(Language);
-   if (TranslationsAvailable() && FileExists(TranslationFile))
+   if (FileExists(TranslationFile))
    {
      FileFd Trans(TranslationFile,FileFd::ReadOnlyGzip);
      debListParser TransParser(&Trans);
diff --git a/apt-pkg/deb/debindexfile.h b/apt-pkg/deb/debindexfile.h
index 6697c5f26..678c22473 100644
--- a/apt-pkg/deb/debindexfile.h
+++ b/apt-pkg/deb/debindexfile.h
@@ -22,6 +22,9 @@
 
 class debStatusIndex : public pkgIndexFile
 {
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+
    protected:
    string File;
 
@@ -41,10 +44,14 @@ class debStatusIndex : public pkgIndexFile
    virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const;
 
    debStatusIndex(string File);
+   virtual ~debStatusIndex() {};
 };
     
 class debPackagesIndex : public pkgIndexFile
 {
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+
    string URI;
    string Dist;
    string Section;
@@ -74,10 +81,14 @@ class debPackagesIndex : public pkgIndexFile
 
    debPackagesIndex(string const &URI, string const &Dist, string const &Section,
 			bool const &Trusted, string const &Arch = "native");
+   virtual ~debPackagesIndex() {};
 };
 
 class debTranslationsIndex : public pkgIndexFile
 {
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+
    string URI;
    string Dist;
    string Section;
@@ -105,10 +116,14 @@ class debTranslationsIndex : public pkgIndexFile
    virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const;
 
    debTranslationsIndex(string URI,string Dist,string Section, char const * const Language);
+   virtual ~debTranslationsIndex() {};
 };
 
 class debSourcesIndex : public pkgIndexFile
 {
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+
    string URI;
    string Dist;
    string Section;
@@ -138,6 +153,7 @@ class debSourcesIndex : public pkgIndexFile
    virtual unsigned long Size() const;
    
    debSourcesIndex(string URI,string Dist,string Section,bool Trusted);
+   virtual ~debSourcesIndex() {};
 };
 
 #endif
diff --git a/apt-pkg/deb/deblistparser.cc b/apt-pkg/deb/deblistparser.cc
index a94b79f05..b708296d3 100644
--- a/apt-pkg/deb/deblistparser.cc
+++ b/apt-pkg/deb/deblistparser.cc
@@ -196,7 +196,7 @@ string debListParser::DescriptionLanguage()
    if (Section.FindS("Description").empty() == false)
       return "";
 
-   std::vector<string> const lang = APT::Configuration::getLanguages();
+   std::vector<string> const lang = APT::Configuration::getLanguages(true);
    for (std::vector<string>::const_iterator l = lang.begin();
 	l != lang.end(); l++)
       if (Section.FindS(string("Description-").append(*l).c_str()).empty() == false)
diff --git a/apt-pkg/deb/deblistparser.h b/apt-pkg/deb/deblistparser.h
index 8b8aff788..41d712fbf 100644
--- a/apt-pkg/deb/deblistparser.h
+++ b/apt-pkg/deb/deblistparser.h
@@ -26,8 +26,11 @@ class debListParser : public pkgCacheGenerator::ListParser
       unsigned char Val;
    };
 
-   protected:
+   private:
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
 
+   protected:
    pkgTagFile Tags;
    pkgTagSection Section;
    unsigned long iOffset;
@@ -74,6 +77,7 @@ class debListParser : public pkgCacheGenerator::ListParser
    static const char *ConvertRelation(const char *I,unsigned int &Op);
 
    debListParser(FileFd *File, string const &Arch = "");
+   virtual ~debListParser() {};
 };
 
 #endif
diff --git a/apt-pkg/deb/debmetaindex.h b/apt-pkg/deb/debmetaindex.h
index 1561c6e00..0aaf7f14a 100644
--- a/apt-pkg/deb/debmetaindex.h
+++ b/apt-pkg/deb/debmetaindex.h
@@ -19,12 +19,14 @@ class debReleaseIndex : public metaIndex {
    };
 
    private:
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
    std::map<string, vector<debSectionEntry const*> > ArchEntries;
 
    public:
 
    debReleaseIndex(string const &URI, string const &Dist);
-   ~debReleaseIndex();
+   virtual ~debReleaseIndex();
 
    virtual string ArchiveURI(string const &File) const {return URI + File;};
    virtual bool GetIndexes(pkgAcquire *Owner, bool const &GetAll=false) const;
diff --git a/apt-pkg/deb/debrecords.cc b/apt-pkg/deb/debrecords.cc
index ec9e395ef..1ca9ae1d2 100644
--- a/apt-pkg/deb/debrecords.cc
+++ b/apt-pkg/deb/debrecords.cc
@@ -77,7 +77,7 @@ string debRecordParser::SHA1Hash()
    return Section.FindS("SHA1");
 }
 									/*}}}*/
-// RecordParser::SHA1Hash - Return the archive hash			/*{{{*/
+// RecordParser::SHA256Hash - Return the archive hash			/*{{{*/
 // ---------------------------------------------------------------------
 /* */
 string debRecordParser::SHA256Hash()
@@ -85,6 +85,14 @@ string debRecordParser::SHA256Hash()
    return Section.FindS("SHA256");
 }
 									/*}}}*/
+// RecordParser::SHA512Hash - Return the archive hash			/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+string debRecordParser::SHA512Hash()
+{
+   return Section.FindS("SHA512");
+}
+									/*}}}*/
 // RecordParser::Maintainer - Return the maintainer email		/*{{{*/
 // ---------------------------------------------------------------------
 /* */
diff --git a/apt-pkg/deb/debrecords.h b/apt-pkg/deb/debrecords.h
index 6f358abfa..9692ac94c 100644
--- a/apt-pkg/deb/debrecords.h
+++ b/apt-pkg/deb/debrecords.h
@@ -20,6 +20,9 @@
 
 class debRecordParser : public pkgRecords::Parser
 {
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+
    FileFd File;
    pkgTagFile Tags;
    pkgTagSection Section;
@@ -36,6 +39,7 @@ class debRecordParser : public pkgRecords::Parser
    virtual string MD5Hash();
    virtual string SHA1Hash();
    virtual string SHA256Hash();
+   virtual string SHA512Hash();
    virtual string SourcePkg();
    virtual string SourceVer();
    
@@ -49,6 +53,7 @@ class debRecordParser : public pkgRecords::Parser
    virtual void GetRec(const char *&Start,const char *&Stop);
    
    debRecordParser(string FileName,pkgCache &Cache);
+   virtual ~debRecordParser() {};
 };
 
 #endif
diff --git a/apt-pkg/deb/debsrcrecords.h b/apt-pkg/deb/debsrcrecords.h
index 905264daa..aa859b0e6 100644
--- a/apt-pkg/deb/debsrcrecords.h
+++ b/apt-pkg/deb/debsrcrecords.h
@@ -18,6 +18,9 @@
 
 class debSrcRecordParser : public pkgSrcRecords::Parser
 {
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+
    FileFd Fd;
    pkgTagFile Tags;
    pkgTagSection Sect;
@@ -50,7 +53,7 @@ class debSrcRecordParser : public pkgSrcRecords::Parser
    debSrcRecordParser(string const &File,pkgIndexFile const *Index) 
       : Parser(Index), Fd(File,FileFd::ReadOnlyGzip), Tags(&Fd,102400), 
         Buffer(0), BufSize(0) {}
-   ~debSrcRecordParser();
+   virtual ~debSrcRecordParser();
 };
 
 #endif
diff --git a/apt-pkg/deb/debsystem.cc b/apt-pkg/deb/debsystem.cc
index 8619822df..7644bc66b 100644
--- a/apt-pkg/deb/debsystem.cc
+++ b/apt-pkg/deb/debsystem.cc
@@ -26,15 +26,24 @@
 
 debSystem debSys;
 
+class debSystemPrivate {
+public:
+   debSystemPrivate() : LockFD(-1), LockCount(0), StatusFile(0)
+   {
+   }
+   // For locking support
+   int LockFD;
+   unsigned LockCount;
+   
+   debStatusIndex *StatusFile;
+};
+
 // System::debSystem - Constructor					/*{{{*/
 // ---------------------------------------------------------------------
 /* */
 debSystem::debSystem()
 {
-   LockFD = -1;
-   LockCount = 0;
-   StatusFile = 0;
-   
+   d = new debSystemPrivate();
    Label = "Debian dpkg interface";
    VS = &debVS;
 }
@@ -44,7 +53,8 @@ debSystem::debSystem()
 /* */
 debSystem::~debSystem()
 {
-   delete StatusFile;
+   delete d->StatusFile;
+   delete d;
 }
 									/*}}}*/
 // System::Lock - Get the lock						/*{{{*/
@@ -54,16 +64,16 @@ debSystem::~debSystem()
 bool debSystem::Lock()
 {
    // Disable file locking
-   if (_config->FindB("Debug::NoLocking",false) == true || LockCount > 1)
+   if (_config->FindB("Debug::NoLocking",false) == true || d->LockCount > 1)
    {
-      LockCount++;
+      d->LockCount++;
       return true;
    }
 
    // Create the lockfile
    string AdminDir = flNotFile(_config->Find("Dir::State::status"));
-   LockFD = GetLock(AdminDir + "lock");
-   if (LockFD == -1)
+   d->LockFD = GetLock(AdminDir + "lock");
+   if (d->LockFD == -1)
    {
       if (errno == EACCES || errno == EAGAIN)
 	 return _error->Error(_("Unable to lock the administration directory (%s), "
@@ -76,8 +86,8 @@ bool debSystem::Lock()
    // See if we need to abort with a dirty journal
    if (CheckUpdates() == true)
    {
-      close(LockFD);
-      LockFD = -1;
+      close(d->LockFD);
+      d->LockFD = -1;
       const char *cmd;
       if (getenv("SUDO_USER") != NULL)
 	 cmd = "sudo dpkg --configure -a";
@@ -89,7 +99,7 @@ bool debSystem::Lock()
                              "run '%s' to correct the problem. "), cmd);
    }
 
-	 LockCount++;
+	 d->LockCount++;
       
    return true;
 }
@@ -99,15 +109,15 @@ bool debSystem::Lock()
 /* */
 bool debSystem::UnLock(bool NoErrors)
 {
-   if (LockCount == 0 && NoErrors == true)
+   if (d->LockCount == 0 && NoErrors == true)
       return false;
    
-   if (LockCount < 1)
+   if (d->LockCount < 1)
       return _error->Error(_("Not locked"));
-   if (--LockCount == 0)
+   if (--d->LockCount == 0)
    {
-      close(LockFD);
-      LockCount = 0;
+      close(d->LockFD);
+      d->LockCount = 0;
    }
    
    return true;
@@ -168,9 +178,9 @@ bool debSystem::Initialize(Configuration &Cnf)
    Cnf.CndSet("Dir::State::status","/var/lib/dpkg/status");
    Cnf.CndSet("Dir::Bin::dpkg","/usr/bin/dpkg");
 
-   if (StatusFile) {
-     delete StatusFile;
-     StatusFile = 0;
+   if (d->StatusFile) {
+     delete d->StatusFile;
+     d->StatusFile = 0;
    }
 
    return true;
@@ -208,9 +218,9 @@ signed debSystem::Score(Configuration const &Cnf)
 /* */
 bool debSystem::AddStatusFiles(vector<pkgIndexFile *> &List)
 {
-   if (StatusFile == 0)
-      StatusFile = new debStatusIndex(_config->FindFile("Dir::State::status"));
-   List.push_back(StatusFile);
+   if (d->StatusFile == 0)
+      d->StatusFile = new debStatusIndex(_config->FindFile("Dir::State::status"));
+   List.push_back(d->StatusFile);
    return true;
 }
 									/*}}}*/
@@ -220,11 +230,11 @@ bool debSystem::AddStatusFiles(vector<pkgIndexFile *> &List)
 bool debSystem::FindIndex(pkgCache::PkgFileIterator File,
 			  pkgIndexFile *&Found) const
 {
-   if (StatusFile == 0)
+   if (d->StatusFile == 0)
       return false;
-   if (StatusFile->FindInCache(*File.Cache()) == File)
+   if (d->StatusFile->FindInCache(*File.Cache()) == File)
    {
-      Found = StatusFile;
+      Found = d->StatusFile;
       return true;
    }
    
diff --git a/apt-pkg/deb/debsystem.h b/apt-pkg/deb/debsystem.h
index 5f9995e5d..232155256 100644
--- a/apt-pkg/deb/debsystem.h
+++ b/apt-pkg/deb/debsystem.h
@@ -12,16 +12,15 @@
 
 #include <apt-pkg/pkgsystem.h>
 
+class debSystemPrivate;
+
 class debStatusIndex;
 class debSystem : public pkgSystem
 {
-   // For locking support
-   int LockFD;
-   unsigned LockCount;
+   // private d-pointer
+   debSystemPrivate *d;
    bool CheckUpdates();
-   
-   debStatusIndex *StatusFile;
-   
+
    public:
 
    virtual bool Lock();
@@ -35,7 +34,7 @@ class debSystem : public pkgSystem
 			  pkgIndexFile *&Found) const;
 
    debSystem();
-   ~debSystem();
+   virtual ~debSystem();
 };
 
 extern debSystem debSys;
diff --git a/apt-pkg/deb/dpkgpm.cc b/apt-pkg/deb/dpkgpm.cc
index b37980b7e..019b72bb8 100644
--- a/apt-pkg/deb/dpkgpm.cc
+++ b/apt-pkg/deb/dpkgpm.cc
@@ -14,8 +14,8 @@
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/pkgrecords.h>
 #include <apt-pkg/strutl.h>
-#include <apti18n.h>
 #include <apt-pkg/fileutl.h>
+#include <apt-pkg/cachefile.h>
 
 #include <unistd.h>
 #include <stdlib.h>
@@ -32,6 +32,8 @@
 #include <algorithm>
 #include <sstream>
 #include <map>
+#include <pwd.h>
+#include <grp.h>
 
 #include <termios.h>
 #include <unistd.h>
@@ -44,6 +46,21 @@
 
 using namespace std;
 
+class pkgDPkgPMPrivate 
+{
+public:
+   pkgDPkgPMPrivate() : dpkgbuf_pos(0), term_out(NULL), history_out(NULL)
+   {
+   }
+   bool stdin_is_dev_null;
+   // the buffer we use for the dpkg status-fd reading
+   char dpkgbuf[1024];
+   int dpkgbuf_pos;
+   FILE *term_out;
+   FILE *history_out;
+   string dpkg_error;
+};
+
 namespace
 {
   // Maps the dpkg "processing" info to human readable names.  Entry 0
@@ -108,9 +125,9 @@ ionice(int PID)
 // ---------------------------------------------------------------------
 /* */
 pkgDPkgPM::pkgDPkgPM(pkgDepCache *Cache) 
-   : pkgPackageManager(Cache), dpkgbuf_pos(0),
-     term_out(NULL), history_out(NULL), PackagesDone(0), PackagesTotal(0)
+   : pkgPackageManager(Cache), PackagesDone(0), PackagesTotal(0)
 {
+   d = new pkgDPkgPMPrivate();
 }
 									/*}}}*/
 // DPkgPM::pkgDPkgPM - Destructor					/*{{{*/
@@ -118,6 +135,7 @@ pkgDPkgPM::pkgDPkgPM(pkgDepCache *Cache)
 /* */
 pkgDPkgPM::~pkgDPkgPM()
 {
+   delete d;
 }
 									/*}}}*/
 // DPkgPM::Install - Install a package					/*{{{*/
@@ -374,7 +392,7 @@ void pkgDPkgPM::DoStdin(int master)
    if (len)
       write(master, input_buf, len);
    else
-      stdin_is_dev_null = true;
+      d->stdin_is_dev_null = true;
 }
 									/*}}}*/
 // DPkgPM::DoTerminalPty - Read the terminal pty and write log		/*{{{*/
@@ -399,8 +417,8 @@ void pkgDPkgPM::DoTerminalPty(int master)
    if(len <= 0) 
       return;
    write(1, term_buf, len);
-   if(term_out)
-      fwrite(term_buf, len, sizeof(char), term_out);
+   if(d->term_out)
+      fwrite(term_buf, len, sizeof(char), d->term_out);
 }
 									/*}}}*/
 // DPkgPM::ProcessDpkgStatusBuf                                        	/*{{{*/
@@ -604,14 +622,14 @@ void pkgDPkgPM::DoDpkgStatusFd(int statusfd, int OutStatusFd)
    char *p, *q;
    int len;
 
-   len=read(statusfd, &dpkgbuf[dpkgbuf_pos], sizeof(dpkgbuf)-dpkgbuf_pos);
-   dpkgbuf_pos += len;
+   len=read(statusfd, &d->dpkgbuf[d->dpkgbuf_pos], sizeof(d->dpkgbuf)-d->dpkgbuf_pos);
+   d->dpkgbuf_pos += len;
    if(len <= 0)
       return;
 
    // process line by line if we have a buffer
-   p = q = dpkgbuf;
-   while((q=(char*)memchr(p, '\n', dpkgbuf+dpkgbuf_pos-p)) != NULL)
+   p = q = d->dpkgbuf;
+   while((q=(char*)memchr(p, '\n', d->dpkgbuf+d->dpkgbuf_pos-p)) != NULL)
    {
       *q = 0;
       ProcessDpkgStatusLine(OutStatusFd, p);
@@ -619,8 +637,8 @@ void pkgDPkgPM::DoDpkgStatusFd(int statusfd, int OutStatusFd)
    }
 
    // now move the unprocessed bits (after the final \n that is now a 0x0) 
-   // to the start and update dpkgbuf_pos
-   p = (char*)memrchr(dpkgbuf, 0, dpkgbuf_pos);
+   // to the start and update d->dpkgbuf_pos
+   p = (char*)memrchr(d->dpkgbuf, 0, d->dpkgbuf_pos);
    if(p == NULL)
       return;
 
@@ -628,8 +646,8 @@ void pkgDPkgPM::DoDpkgStatusFd(int statusfd, int OutStatusFd)
    p++;
 
    // move the unprocessed tail to the start and update pos
-   memmove(dpkgbuf, p, p-dpkgbuf);
-   dpkgbuf_pos = dpkgbuf+dpkgbuf_pos-p;
+   memmove(d->dpkgbuf, p, p-d->dpkgbuf);
+   d->dpkgbuf_pos = d->dpkgbuf+d->dpkgbuf_pos-p;
 }
 									/*}}}*/
 // DPkgPM::WriteHistoryTag						/*{{{*/
@@ -641,7 +659,7 @@ void pkgDPkgPM::WriteHistoryTag(string const &tag, string value)
    // poor mans rstrip(", ")
    if (value[length-2] == ',' && value[length-1] == ' ')
       value.erase(length - 2, 2);
-   fprintf(history_out, "%s: %s\n", tag.c_str(), value.c_str());
+   fprintf(d->history_out, "%s: %s\n", tag.c_str(), value.c_str());
 }									/*}}}*/
 // DPkgPM::OpenLog							/*{{{*/
 bool pkgDPkgPM::OpenLog()
@@ -662,13 +680,19 @@ bool pkgDPkgPM::OpenLog()
 				   _config->Find("Dir::Log::Terminal"));
    if (!logfile_name.empty())
    {
-      term_out = fopen(logfile_name.c_str(),"a");
-      if (term_out == NULL)
+      d->term_out = fopen(logfile_name.c_str(),"a");
+      if (d->term_out == NULL)
 	 return _error->WarningE("OpenLog", _("Could not open file '%s'"), logfile_name.c_str());
-      setvbuf(term_out, NULL, _IONBF, 0);
-      SetCloseExec(fileno(term_out), true);
-      chmod(logfile_name.c_str(), 0600);
-      fprintf(term_out, "\nLog started: %s\n", timestr);
+      setvbuf(d->term_out, NULL, _IONBF, 0);
+      SetCloseExec(fileno(d->term_out), true);
+      struct passwd *pw;
+      struct group *gr;
+      pw = getpwnam("root");
+      gr = getgrnam("adm");
+      if (pw != NULL && gr != NULL)
+	  chown(logfile_name.c_str(), pw->pw_uid, gr->gr_gid);
+      chmod(logfile_name.c_str(), 0644);
+      fprintf(d->term_out, "\nLog started: %s\n", timestr);
    }
 
    // write your history
@@ -676,41 +700,52 @@ bool pkgDPkgPM::OpenLog()
 				   _config->Find("Dir::Log::History"));
    if (!history_name.empty())
    {
-      history_out = fopen(history_name.c_str(),"a");
-      if (history_out == NULL)
+      d->history_out = fopen(history_name.c_str(),"a");
+      if (d->history_out == NULL)
 	 return _error->WarningE("OpenLog", _("Could not open file '%s'"), history_name.c_str());
       chmod(history_name.c_str(), 0644);
-      fprintf(history_out, "\nStart-Date: %s\n", timestr);
-      string remove, purge, install, upgrade, downgrade;
+      fprintf(d->history_out, "\nStart-Date: %s\n", timestr);
+      string remove, purge, install, reinstall, upgrade, downgrade;
       for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
       {
-	 if (Cache[I].NewInstall())
-	 {
-	    install += I.FullName(false) + string(" (") + Cache[I].CandVersion;
-	    if (Cache[I].Flags & pkgCache::Flag::Auto)
-	       install+= ", automatic";
-	    install += string("), ");
-	 }
-	 else if (Cache[I].Upgrade())
-	    upgrade += I.FullName(false) + string(" (") + Cache[I].CurVersion + string(", ") + Cache[I].CandVersion + string("), ");
-	 else if (Cache[I].Downgrade())
-	    downgrade += I.FullName(false) + string(" (") + Cache[I].CurVersion + string(", ") + Cache[I].CandVersion + string("), ");
-	 else if (Cache[I].Delete())
-	 {
-	    if ((Cache[I].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge)
-	       purge += I.FullName(false) + string(" (") + Cache[I].CurVersion + string("), ");	    
-	    else
-	       remove += I.FullName(false) + string(" (") + Cache[I].CurVersion + string("), ");	    
+	 enum { CANDIDATE, CANDIDATE_AUTO, CURRENT_CANDIDATE, CURRENT } infostring;
+	 string *line = NULL;
+	 #define HISTORYINFO(X, Y) { line = &X; infostring = Y; }
+	 if (Cache[I].NewInstall() == true)
+	    HISTORYINFO(install, CANDIDATE_AUTO)
+	 else if (Cache[I].ReInstall() == true)
+	    HISTORYINFO(reinstall, CANDIDATE)
+	 else if (Cache[I].Upgrade() == true)
+	    HISTORYINFO(upgrade, CURRENT_CANDIDATE)
+	 else if (Cache[I].Downgrade() == true)
+	    HISTORYINFO(downgrade, CURRENT_CANDIDATE)
+	 else if (Cache[I].Delete() == true)
+	    HISTORYINFO((Cache[I].Purge() ? purge : remove), CURRENT)
+	 else
+	    continue;
+	 #undef HISTORYINFO
+	 line->append(I.FullName(false)).append(" (");
+	 switch (infostring) {
+	 case CANDIDATE: line->append(Cache[I].CandVersion); break;
+	 case CANDIDATE_AUTO:
+	    line->append(Cache[I].CandVersion);
+	    if ((Cache[I].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
+	       line->append(", automatic");
+	    break;
+	 case CURRENT_CANDIDATE: line->append(Cache[I].CurVersion).append(", ").append(Cache[I].CandVersion); break;
+	 case CURRENT: line->append(Cache[I].CurVersion); break;
 	 }
+	 line->append("), ");
       }
       if (_config->Exists("Commandline::AsString") == true)
 	 WriteHistoryTag("Commandline", _config->Find("Commandline::AsString"));
       WriteHistoryTag("Install", install);
+      WriteHistoryTag("Reinstall", reinstall);
       WriteHistoryTag("Upgrade", upgrade);
       WriteHistoryTag("Downgrade",downgrade);
       WriteHistoryTag("Remove",remove);
       WriteHistoryTag("Purge",purge);
-      fflush(history_out);
+      fflush(d->history_out);
    }
    
    return true;
@@ -724,16 +759,16 @@ bool pkgDPkgPM::CloseLog()
    struct tm *tmp = localtime(&t);
    strftime(timestr, sizeof(timestr), "%F  %T", tmp);
 
-   if(term_out)
+   if(d->term_out)
    {
-      fprintf(term_out, "Log ended: ");
-      fprintf(term_out, "%s", timestr);
-      fprintf(term_out, "\n");
-      fclose(term_out);
+      fprintf(d->term_out, "Log ended: ");
+      fprintf(d->term_out, "%s", timestr);
+      fprintf(d->term_out, "\n");
+      fclose(d->term_out);
    }
-   term_out = NULL;
+   d->term_out = NULL;
 
-   if(history_out)
+   if(d->history_out)
    {
       if (disappearedPkgs.empty() == false)
       {
@@ -750,12 +785,12 @@ bool pkgDPkgPM::CloseLog()
 	 }
 	 WriteHistoryTag("Disappeared", disappear);
       }
-      if (dpkg_error.empty() == false)
-	 fprintf(history_out, "Error: %s\n", dpkg_error.c_str());
-      fprintf(history_out, "End-Date: %s\n", timestr);
-      fclose(history_out);
+      if (d->dpkg_error.empty() == false)
+	 fprintf(d->history_out, "Error: %s\n", d->dpkg_error.c_str());
+      fprintf(d->history_out, "End-Date: %s\n", timestr);
+      fclose(d->history_out);
    }
-   history_out = NULL;
+   d->history_out = NULL;
 
    return true;
 }
@@ -863,7 +898,7 @@ bool pkgDPkgPM::Go(int OutStatusFd)
       }
    }
 
-   stdin_is_dev_null = false;
+   d->stdin_is_dev_null = false;
 
    // create log
    OpenLog();
@@ -1063,8 +1098,8 @@ bool pkgDPkgPM::Go(int OutStatusFd)
 	    const char *s = _("Can not write log, openpty() "
 	                      "failed (/dev/pts not mounted?)\n");
 	    fprintf(stderr, "%s",s);
-            if(term_out)
-              fprintf(term_out, "%s",s);
+            if(d->term_out)
+              fprintf(d->term_out, "%s",s);
 	    master = slave = -1;
 	 }  else {
 	    struct termios rtt;
@@ -1194,7 +1229,7 @@ bool pkgDPkgPM::Go(int OutStatusFd)
 
 	 // wait for input or output here
 	 FD_ZERO(&rfds);
-	 if (master >= 0 && !stdin_is_dev_null)
+	 if (master >= 0 && !d->stdin_is_dev_null)
 	    FD_SET(0, &rfds); 
 	 FD_SET(_dpkgin, &rfds);
 	 if(master >= 0)
@@ -1248,14 +1283,14 @@ bool pkgDPkgPM::Go(int OutStatusFd)
 	    RunScripts("DPkg::Post-Invoke");
 
 	 if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV) 
-	    strprintf(dpkg_error, "Sub-process %s received a segmentation fault.",Args[0]);
+	    strprintf(d->dpkg_error, "Sub-process %s received a segmentation fault.",Args[0]);
 	 else if (WIFEXITED(Status) != 0)
-	    strprintf(dpkg_error, "Sub-process %s returned an error code (%u)",Args[0],WEXITSTATUS(Status));
+	    strprintf(d->dpkg_error, "Sub-process %s returned an error code (%u)",Args[0],WEXITSTATUS(Status));
 	 else 
-	    strprintf(dpkg_error, "Sub-process %s exited unexpectedly",Args[0]);
+	    strprintf(d->dpkg_error, "Sub-process %s exited unexpectedly",Args[0]);
 
-	 if(dpkg_error.size() > 0)
-	    _error->Error("%s", dpkg_error.c_str());
+	 if(d->dpkg_error.size() > 0)
+	    _error->Error("%s", d->dpkg_error.c_str());
 
 	 if(stopOnError) 
 	 {
@@ -1269,6 +1304,23 @@ bool pkgDPkgPM::Go(int OutStatusFd)
    if (RunScripts("DPkg::Post-Invoke") == false)
       return false;
 
+   if (_config->FindB("Debug::pkgDPkgPM",false) == false)
+   {
+      std::string const oldpkgcache = _config->FindFile("Dir::cache::pkgcache");
+      if (oldpkgcache.empty() == false && RealFileExists(oldpkgcache) == true &&
+	  unlink(oldpkgcache.c_str()) == 0)
+      {
+	 std::string const srcpkgcache = _config->FindFile("Dir::cache::srcpkgcache");
+	 if (srcpkgcache.empty() == false && RealFileExists(srcpkgcache) == true)
+	 {
+	    _error->PushToStack();
+	    pkgCacheFile CacheFile;
+	    CacheFile.BuildCaches(NULL, true);
+	    _error->RevertToStack();
+	 }
+      }
+   }
+
    Cache.writeStateFile(NULL);
    return true;
 }
@@ -1402,8 +1454,8 @@ void pkgDPkgPM::WriteApportReport(const char *pkgpath, const char *errormsg)
    fprintf(report, "ErrorMessage:\n %s\n", errormsg);
 
    // ensure that the log is flushed
-   if(term_out)
-      fflush(term_out);
+   if(d->term_out)
+      fflush(d->term_out);
 
    // attach terminal log it if we have it
    string logfile_name = _config->FindFile("Dir::Log::Terminal");
diff --git a/apt-pkg/deb/dpkgpm.h b/apt-pkg/deb/dpkgpm.h
index b7b5a6def..ddf9485c7 100644
--- a/apt-pkg/deb/dpkgpm.h
+++ b/apt-pkg/deb/dpkgpm.h
@@ -18,19 +18,12 @@
 using std::vector;
 using std::map;
 
+class pkgDPkgPMPrivate;
 
 class pkgDPkgPM : public pkgPackageManager
 {
    private:
-
-   bool stdin_is_dev_null;
-
-   // the buffer we use for the dpkg status-fd reading
-   char dpkgbuf[1024];
-   int dpkgbuf_pos;
-   FILE *term_out;
-   FILE *history_out;
-   string dpkg_error;
+   pkgDPkgPMPrivate *d;
 
    /** \brief record the disappear action and handle accordingly
 
diff --git a/apt-pkg/depcache.h b/apt-pkg/depcache.h
index 2942558b0..adc010c28 100644
--- a/apt-pkg/depcache.h
+++ b/apt-pkg/depcache.h
@@ -231,6 +231,7 @@ class pkgDepCache : protected pkgCache::Namespace
       // Various test members for the current status of the package
       inline bool NewInstall() const {return Status == 2 && Mode == ModeInstall;};
       inline bool Delete() const {return Mode == ModeDelete;};
+      inline bool Purge() const {return Delete() == true && (iFlags & pkgDepCache::Purge) == pkgDepCache::Purge; };
       inline bool Keep() const {return Mode == ModeKeep;};
       inline bool Protect() const {return (iFlags & Protected) == Protected;};
       inline bool Upgrade() const {return Status > 0 && Mode == ModeInstall;};
@@ -242,6 +243,7 @@ class pkgDepCache : protected pkgCache::Namespace
       inline bool InstBroken() const {return (DepState & DepInstMin) != DepInstMin;};
       inline bool InstPolicyBroken() const {return (DepState & DepInstPolicy) != DepInstPolicy;};
       inline bool Install() const {return Mode == ModeInstall;};
+      inline bool ReInstall() const {return Delete() == false && (iFlags & pkgDepCache::ReInstall) == pkgDepCache::ReInstall;};
       inline VerIterator InstVerIter(pkgCache &Cache)
                 {return VerIterator(Cache,InstallVer);};
       inline VerIterator CandidateVerIter(pkgCache &Cache)
diff --git a/apt-pkg/edsp/edspindexfile.h b/apt-pkg/edsp/edspindexfile.h
index 87c06557c..0053388eb 100644
--- a/apt-pkg/edsp/edspindexfile.h
+++ b/apt-pkg/edsp/edspindexfile.h
@@ -13,6 +13,9 @@
 
 class edspIndex : public debStatusIndex
 {
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+
    public:
 
    virtual const Type *GetType() const;
diff --git a/apt-pkg/edsp/edspsystem.h b/apt-pkg/edsp/edspsystem.h
index bc5be61d1..ca703fa84 100644
--- a/apt-pkg/edsp/edspsystem.h
+++ b/apt-pkg/edsp/edspsystem.h
@@ -15,6 +15,9 @@
 class edspIndex;
 class edspSystem : public pkgSystem
 {
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+
    edspIndex *StatusFile;
 
    public:
diff --git a/apt-pkg/indexcopy.h b/apt-pkg/indexcopy.h
index 6fcd3b8ce..277fb561c 100644
--- a/apt-pkg/indexcopy.h
+++ b/apt-pkg/indexcopy.h
@@ -24,6 +24,9 @@ class pkgCdromStatus;
 
 class IndexCopy								/*{{{*/
 {
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+
    protected:
    
    pkgTagSection *Section;
@@ -55,7 +58,6 @@ class PackageCopy : public IndexCopy					/*{{{*/
    virtual const char *GetFileName() {return "Packages";};
    virtual const char *Type() {return "Package";};
    
-   public:
 };
 									/*}}}*/
 class SourceCopy : public IndexCopy					/*{{{*/
@@ -67,7 +69,6 @@ class SourceCopy : public IndexCopy					/*{{{*/
    virtual const char *GetFileName() {return "Sources";};
    virtual const char *Type() {return "Source";};
    
-   public:
 };
 									/*}}}*/
 class TranslationsCopy							/*{{{*/
@@ -82,6 +83,9 @@ class TranslationsCopy							/*{{{*/
 									/*}}}*/
 class SigVerify								/*{{{*/
 {
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
+
    bool Verify(string prefix,string file, indexRecords *records);
    bool CopyMetaIndex(string CDROM, string CDName, 
 		      string prefix, string file);
diff --git a/apt-pkg/init.cc b/apt-pkg/init.cc
index aff585e3b..66b0119e6 100644
--- a/apt-pkg/init.cc
+++ b/apt-pkg/init.cc
@@ -87,9 +87,6 @@ bool pkgInitConfig(Configuration &Cnf)
    Cnf.Set("Dir::Ignore-Files-Silently::", "\\.bak$");
    Cnf.Set("Dir::Ignore-Files-Silently::", "\\.dpkg-[a-z]+$");
 
-   // Translation
-   Cnf.Set("APT::Acquire::Translation", "environment");
-
    // Default cdrom mount point
    Cnf.Set("Acquire::cdrom::mount", "/media/cdrom/");
 
diff --git a/apt-pkg/init.h b/apt-pkg/init.h
index 15a1165b9..6b92dd200 100644
--- a/apt-pkg/init.h
+++ b/apt-pkg/init.h
@@ -22,8 +22,8 @@
 // Non-ABI-Breaks should only increase RELEASE number.
 // See also buildlib/libversion.mak
 #define APT_PKG_MAJOR 4
-#define APT_PKG_MINOR 10
-#define APT_PKG_RELEASE 1
+#define APT_PKG_MINOR 11
+#define APT_PKG_RELEASE 0
     
 extern const char *pkgVersion;
 extern const char *pkgLibVersion;
diff --git a/apt-pkg/makefile b/apt-pkg/makefile
index e6bcf8524..b11e35250 100644
--- a/apt-pkg/makefile
+++ b/apt-pkg/makefile
@@ -20,11 +20,15 @@ APT_DOMAIN:=libapt-pkg$(LIBAPTPKG_MAJOR)
 # Source code for the contributed non-core things
 SOURCE = contrib/mmap.cc contrib/error.cc contrib/strutl.cc \
          contrib/configuration.cc contrib/progress.cc contrib/cmndline.cc \
-	 contrib/md5.cc contrib/sha1.cc contrib/sha256.cc contrib/hashes.cc \
+	 contrib/md5.cc contrib/sha1.cc contrib/sha2.cc  \
+	 contrib/sha2_internal.cc\
+         contrib/hashes.cc \
 	 contrib/cdromutl.cc contrib/crc-16.cc contrib/netrc.cc \
 	 contrib/fileutl.cc 
 HEADERS = mmap.h error.h configuration.h fileutl.h  cmndline.h netrc.h\
-	  md5.h crc-16.h cdromutl.h strutl.h sptr.h sha1.h sha256.h hashes.h \
+	  md5.h crc-16.h cdromutl.h strutl.h sptr.h sha1.h sha2.h \
+	  sha2_internal.h \
+          hashes.h hashsum_template.h\
 	  macros.h weakptr.h
 
 # Source code for the core main library
diff --git a/apt-pkg/orderlist.cc b/apt-pkg/orderlist.cc
index ba43bc757..19661fc2d 100644
--- a/apt-pkg/orderlist.cc
+++ b/apt-pkg/orderlist.cc
@@ -1073,6 +1073,12 @@ bool pkgOrderList::CheckDep(DepIterator D)
          just needs one */
       if (D.IsNegative() == false)
       {
+	 // ignore provides by older versions of this package
+	 if (((D.Reverse() == false && Pkg == D.ParentPkg()) ||
+	      (D.Reverse() == true && Pkg == D.TargetPkg())) &&
+	     Cache[Pkg].InstallVer != *I)
+	    continue;
+
 	 /* Try to find something that does not have the after flag set
 	    if at all possible */
 	 if (IsFlag(Pkg,After) == true)
diff --git a/apt-pkg/pkgrecords.h b/apt-pkg/pkgrecords.h
index c2c98188a..78e39e577 100644
--- a/apt-pkg/pkgrecords.h
+++ b/apt-pkg/pkgrecords.h
@@ -28,12 +28,13 @@ class pkgRecords							/*{{{*/
    class Parser;
    
    private:
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
    
    pkgCache &Cache;
    std::vector<Parser *>Files;
 
-   public:
-
+    public:
    // Lookup function
    Parser &Lookup(pkgCache::VerFileIterator const &Ver);
    Parser &Lookup(pkgCache::DescFileIterator const &Desc);
@@ -58,6 +59,7 @@ class pkgRecords::Parser						/*{{{*/
    virtual string MD5Hash() {return string();};
    virtual string SHA1Hash() {return string();};
    virtual string SHA256Hash() {return string();};
+   virtual string SHA512Hash() {return string();};
    virtual string SourcePkg() {return string();};
    virtual string SourceVer() {return string();};
 
diff --git a/apt-pkg/srcrecords.h b/apt-pkg/srcrecords.h
index a49533864..8a78d7711 100644
--- a/apt-pkg/srcrecords.h
+++ b/apt-pkg/srcrecords.h
@@ -79,6 +79,8 @@ class pkgSrcRecords
    };
    
    private:
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void *d;
    
    // The list of files and the current parser pointer
    vector<Parser*> Files;
@@ -93,7 +95,7 @@ class pkgSrcRecords
    Parser *Find(const char *Package,bool const &SrcOnly = false);
    
    pkgSrcRecords(pkgSourceList &List);
-   ~pkgSrcRecords();
+   virtual ~pkgSrcRecords();
 };
 
 #endif
diff --git a/apt-pkg/tagfile.cc b/apt-pkg/tagfile.cc
index 4a2f3f7e6..a8f04b23a 100644
--- a/apt-pkg/tagfile.cc
+++ b/apt-pkg/tagfile.cc
@@ -24,26 +24,40 @@
 
 using std::string;
 
+class pkgTagFilePrivate
+{
+public:
+   pkgTagFilePrivate(FileFd *pFd, unsigned long Size) : Fd(*pFd), Size(Size)
+   {
+   }
+   FileFd &Fd;
+   char *Buffer;
+   char *Start;
+   char *End;
+   bool Done;
+   unsigned long iOffset;
+   unsigned long Size;
+};
+
 // TagFile::pkgTagFile - Constructor					/*{{{*/
 // ---------------------------------------------------------------------
 /* */
-pkgTagFile::pkgTagFile(FileFd *pFd,unsigned long Size) :
-     Fd(*pFd),
-     Size(Size)
+pkgTagFile::pkgTagFile(FileFd *pFd,unsigned long Size)
 {
-   if (Fd.IsOpen() == false)
+   d = new pkgTagFilePrivate(pFd, Size);
+
+   if (d->Fd.IsOpen() == false)
    {
-      Buffer = 0;
-      Start = End = Buffer = 0;
-      Done = true;
-      iOffset = 0;
+      d->Start = d->End = d->Buffer = 0;
+      d->Done = true;
+      d->iOffset = 0;
       return;
    }
    
-   Buffer = new char[Size];
-   Start = End = Buffer;
-   Done = false;
-   iOffset = 0;
+   d->Buffer = new char[Size];
+   d->Start = d->End = d->Buffer;
+   d->Done = false;
+   d->iOffset = 0;
    Fill();
 }
 									/*}}}*/
@@ -52,7 +66,14 @@ pkgTagFile::pkgTagFile(FileFd *pFd,unsigned long Size) :
 /* */
 pkgTagFile::~pkgTagFile()
 {
-   delete [] Buffer;
+   delete [] d->Buffer;
+   delete d;
+}
+									/*}}}*/
+// TagFile::Offset - Return the current offset in the buffer     	/*{{{*/
+unsigned long pkgTagFile::Offset()
+{
+   return d->iOffset;
 }
 									/*}}}*/
 // TagFile::Resize - Resize the internal buffer				/*{{{*/
@@ -63,22 +84,22 @@ pkgTagFile::~pkgTagFile()
 bool pkgTagFile::Resize()
 {
    char *tmp;
-   unsigned long EndSize = End - Start;
+   unsigned long EndSize = d->End - d->Start;
 
    // fail is the buffer grows too big
-   if(Size > 1024*1024+1)
+   if(d->Size > 1024*1024+1)
       return false;
 
    // get new buffer and use it
-   tmp = new char[2*Size];
-   memcpy(tmp, Buffer, Size);
-   Size = Size*2;
-   delete [] Buffer;
-   Buffer = tmp;
+   tmp = new char[2*d->Size];
+   memcpy(tmp, d->Buffer, d->Size);
+   d->Size = d->Size*2;
+   delete [] d->Buffer;
+   d->Buffer = tmp;
 
    // update the start/end pointers to the new buffer
-   Start = Buffer;
-   End = Start + EndSize;
+   d->Start = d->Buffer;
+   d->End = d->Start + EndSize;
    return true;
 }
 									/*}}}*/
@@ -90,20 +111,20 @@ bool pkgTagFile::Resize()
  */
 bool pkgTagFile::Step(pkgTagSection &Tag)
 {
-   while (Tag.Scan(Start,End - Start) == false)
+   while (Tag.Scan(d->Start,d->End - d->Start) == false)
    {
       if (Fill() == false)
 	 return false;
       
-      if(Tag.Scan(Start,End - Start))
+      if(Tag.Scan(d->Start,d->End - d->Start))
 	 break;
 
       if (Resize() == false)
 	 return _error->Error(_("Unable to parse package file %s (1)"),
-				 Fd.Name().c_str());
+                              d->Fd.Name().c_str());
    }
-   Start += Tag.size();
-   iOffset += Tag.size();
+   d->Start += Tag.size();
+   d->iOffset += Tag.size();
 
    Tag.Trim();
    return true;
@@ -115,37 +136,37 @@ bool pkgTagFile::Step(pkgTagSection &Tag)
    then fills the rest from the file */
 bool pkgTagFile::Fill()
 {
-   unsigned long EndSize = End - Start;
+   unsigned long EndSize = d->End - d->Start;
    unsigned long Actual = 0;
    
-   memmove(Buffer,Start,EndSize);
-   Start = Buffer;
-   End = Buffer + EndSize;
+   memmove(d->Buffer,d->Start,EndSize);
+   d->Start = d->Buffer;
+   d->End = d->Buffer + EndSize;
    
-   if (Done == false)
+   if (d->Done == false)
    {
       // See if only a bit of the file is left
-      if (Fd.Read(End,Size - (End - Buffer),&Actual) == false)
+      if (d->Fd.Read(d->End, d->Size - (d->End - d->Buffer),&Actual) == false)
 	 return false;
-      if (Actual != Size - (End - Buffer))
-	 Done = true;
-      End += Actual;
+      if (Actual != d->Size - (d->End - d->Buffer))
+	 d->Done = true;
+      d->End += Actual;
    }
    
-   if (Done == true)
+   if (d->Done == true)
    {
       if (EndSize <= 3 && Actual == 0)
 	 return false;
-      if (Size - (End - Buffer) < 4)
+      if (d->Size - (d->End - d->Buffer) < 4)
 	 return true;
       
       // Append a double new line if one does not exist
       unsigned int LineCount = 0;
-      for (const char *E = End - 1; E - End < 6 && (*E == '\n' || *E == '\r'); E--)
+      for (const char *E = d->End - 1; E - d->End < 6 && (*E == '\n' || *E == '\r'); E--)
 	 if (*E == '\n')
 	    LineCount++;
       for (; LineCount < 2; LineCount++)
-	 *End++ = '\n';
+	 *d->End++ = '\n';
       
       return true;
    }
@@ -160,33 +181,33 @@ bool pkgTagFile::Fill()
 bool pkgTagFile::Jump(pkgTagSection &Tag,unsigned long Offset)
 {
    // We are within a buffer space of the next hit..
-   if (Offset >= iOffset && iOffset + (End - Start) > Offset)
+   if (Offset >= d->iOffset && d->iOffset + (d->End - d->Start) > Offset)
    {
-      unsigned long Dist = Offset - iOffset;
-      Start += Dist;
-      iOffset += Dist;
+      unsigned long Dist = Offset - d->iOffset;
+      d->Start += Dist;
+      d->iOffset += Dist;
       return Step(Tag);
    }
 
    // Reposition and reload..
-   iOffset = Offset;
-   Done = false;
-   if (Fd.Seek(Offset) == false)
+   d->iOffset = Offset;
+   d->Done = false;
+   if (d->Fd.Seek(Offset) == false)
       return false;
-   End = Start = Buffer;
+   d->End = d->Start = d->Buffer;
    
    if (Fill() == false)
       return false;
 
-   if (Tag.Scan(Start,End - Start) == true)
+   if (Tag.Scan(d->Start, d->End - d->Start) == true)
       return true;
    
    // This appends a double new line (for the real eof handling)
    if (Fill() == false)
       return false;
    
-   if (Tag.Scan(Start,End - Start) == false)
-      return _error->Error(_("Unable to parse package file %s (2)"),Fd.Name().c_str());
+   if (Tag.Scan(d->Start, d->End - d->Start) == false)
+      return _error->Error(_("Unable to parse package file %s (2)"),d->Fd.Name().c_str());
    
    return true;
 }
@@ -457,6 +478,7 @@ static const char *iTFRewritePackageOrder[] = {
                           "MD5Sum",
                           "SHA1",
                           "SHA256",
+                          "SHA512",
                            "MSDOS-Filename",   // Obsolete
                           "Description",
                           0};
diff --git a/apt-pkg/tagfile.h b/apt-pkg/tagfile.h
index 61491aa04..23f5c57e6 100644
--- a/apt-pkg/tagfile.h
+++ b/apt-pkg/tagfile.h
@@ -23,16 +23,16 @@
 
 #include <apt-pkg/fileutl.h>
 #include <stdio.h>
-    
+
 class pkgTagSection
 {
    const char *Section;
-   
    // We have a limit of 256 tags per section.
    unsigned int Indexes[256];
    unsigned int AlphaIndexes[0x100];
-   
    unsigned int TagCount;
+   // dpointer placeholder (for later in case we need it)
+   void *d;
 
    /* This very simple hash function for the last 8 letters gives
       very good performance on the debian package files */
@@ -44,7 +44,6 @@ class pkgTagSection
       return Res & 0xFF;
    }
 
-
    protected:
    const char *Stop;
 
@@ -80,17 +79,13 @@ class pkgTagSection
    };
    
    pkgTagSection() : Section(0), Stop(0) {};
+   virtual ~pkgTagSection() {};
 };
 
+class pkgTagFilePrivate;
 class pkgTagFile
 {
-   FileFd &Fd;
-   char *Buffer;
-   char *Start;
-   char *End;
-   bool Done;
-   unsigned long iOffset;
-   unsigned long Size;
+   pkgTagFilePrivate *d;
 
    bool Fill();
    bool Resize();
@@ -98,11 +93,11 @@ class pkgTagFile
    public:
 
    bool Step(pkgTagSection &Section);
-   inline unsigned long Offset() {return iOffset;};
+   unsigned long Offset();
    bool Jump(pkgTagSection &Tag,unsigned long Offset);
 
    pkgTagFile(FileFd *F,unsigned long Size = 32*1024);
-   ~pkgTagFile();
+   virtual ~pkgTagFile();
 };
 
 /* This is the list of things to rewrite. The rewriter