Merge remote-tracking branch 'upstream/debian/experimental' into feature/acq-trans

[apt.git] / apt-pkg / acquire-item.cc

diff --git a/apt-pkg/acquire-item.cc b/apt-pkg/acquire-item.cc
index 54e99345865587a1fe725c4fb21bf244c59b8a52..5d0a00055501ca1235746209a7cb8ca76a5cd9c8 100644 (file)
--- a/apt-pkg/acquire-item.cc
+++ b/apt-pkg/acquire-item.cc
@@ -44,6 +44,9 @@
 #include <sstream>
 #include <stdio.h>
 #include <ctime>
 #include <sstream>
 #include <stdio.h>
 #include <ctime>

+#include <sys/types.h>
+#include <pwd.h>
+#include <grp.h>

 
 #include <apti18n.h>
                                                                        /*}}}*/
 
 #include <apti18n.h>
                                                                        /*}}}*/


@@ -62,6 +65,30 @@ static void printHashSumComparision(std::string const &URI, HashStringList const
       std::cerr <<  "\t- " << hs->toStr() << std::endl;
 }
                                                                        /*}}}*/
       std::cerr <<  "\t- " << hs->toStr() << std::endl;
 }
                                                                        /*}}}*/

+static void ChangeOwnerAndPermissionOfFile(char const * const requester, char const * const file, char const * const user, char const * const group, mode_t const mode)
+{
+   // ensure the file is owned by root and has good permissions
+   struct passwd const * const pw = getpwnam(user);
+   struct group const * const gr = getgrnam(group);
+   if (getuid() == 0) // if we aren't root, we can't chown, so don't try it
+   {
+      if (pw != NULL && gr != NULL && chown(file, pw->pw_uid, gr->gr_gid) != 0)
+        _error->WarningE(requester, "chown to %s:%s of file %s failed", user, group, file);
+   }
+   if (chmod(file, mode) != 0)
+      _error->WarningE(requester, "chmod 0%o of file %s failed", mode, file);
+}
+static std::string GetPartialFileName(std::string const &file)
+{
+   std::string DestFile = _config->FindDir("Dir::State::lists") + "partial/";
+   DestFile += file;
+   return DestFile;
+}
+static std::string GetPartialFileNameFromURI(std::string const &uri)
+{
+   return GetPartialFileName(URItoFileName(uri));
+}
+

 
 // Acquire::Item::Item - Constructor                                   /*{{{*/
 #if __GNUC__ >= 4
 
 // Acquire::Item::Item - Constructor                                   /*{{{*/
 #if __GNUC__ >= 4


@@ -98,7 +125,6 @@ pkgAcquire::Item::~Item()
    fetch this object */
 void pkgAcquire::Item::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 {
    fetch this object */
 void pkgAcquire::Item::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 {

-   Status = StatIdle;

    if(ErrorText == "")
       ErrorText = LookupTag(Message,"Message");
    UsedMirror =  LookupTag(Message,"UsedMirror");
    if(ErrorText == "")
       ErrorText = LookupTag(Message,"Message");
    UsedMirror =  LookupTag(Message,"UsedMirror");


@@ -107,7 +133,7 @@ void pkgAcquire::Item::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
       /* This indicates that the file is not available right now but might
          be sometime later. If we do a retry cycle then this should be
         retried [CDROMs] */
       /* This indicates that the file is not available right now but might
          be sometime later. If we do a retry cycle then this should be
         retried [CDROMs] */

-      if (Cnf->LocalOnly == true &&
+      if (Cnf != NULL && Cnf->LocalOnly == true &&

          StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
       {
         Status = StatIdle;
          StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
       {
         Status = StatIdle;


@@ -116,8 +142,11 @@ void pkgAcquire::Item::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
       }
 
       Status = StatError;
       }
 
       Status = StatError;

+      Complete = false;

       Dequeue();
       Dequeue();

-   }   
+   }
+   else
+      Status = StatIdle;

 
    // report mirror failure back to LP if we actually use a mirror
    string FailReason = LookupTag(Message, "FailReason");
 
    // report mirror failure back to LP if we actually use a mirror
    string FailReason = LookupTag(Message, "FailReason");


@@ -178,6 +207,18 @@ bool pkgAcquire::Item::Rename(string From,string To)
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

+
+void pkgAcquire::Item::QueueURI(ItemDesc &Item)
+{
+   if (RealFileExists(DestFile))
+      ChangeOwnerAndPermissionOfFile("GetPartialFileName", DestFile.c_str(), "_apt", "root", 0600);
+   Owner->Enqueue(Item);
+}
+void pkgAcquire::Item::Dequeue()
+{
+   Owner->Dequeue(this);
+}
+

 bool pkgAcquire::Item::RenameOnError(pkgAcquire::Item::RenameOnErrorState const error)/*{{{*/
 {
    if(FileExists(DestFile))
 bool pkgAcquire::Item::RenameOnError(pkgAcquire::Item::RenameOnErrorState const error)/*{{{*/
 {
    if(FileExists(DestFile))


@@ -210,6 +251,19 @@ bool pkgAcquire::Item::RenameOnError(pkgAcquire::Item::RenameOnErrorState const
         break;
    }
    return false;
         break;
    }
    return false;

+}
+                                                                       /*}}}*/
+void pkgAcquire::Item::SetActiveSubprocess(const std::string &subprocess)/*{{{*/
+{
+      ActiveSubprocess = subprocess;
+#if __GNUC__ >= 4
+       #pragma GCC diagnostic push
+       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+        Mode = ActiveSubprocess.c_str();
+#if __GNUC__ >= 4
+       #pragma GCC diagnostic pop
+#endif

 }
                                                                        /*}}}*/
 // Acquire::Item::ReportMirrorFailure                                  /*{{{*/
 }
                                                                        /*}}}*/
 // Acquire::Item::ReportMirrorFailure                                  /*{{{*/


@@ -269,19 +323,18 @@ pkgAcqDiffIndex::pkgAcqDiffIndex(pkgAcquire *Owner,
                                 HashStringList const &ExpectedHashes,
                                  indexRecords *MetaIndexParser)
    : pkgAcqBaseIndex(Owner, TransactionManager, Target, ExpectedHashes, 
                                 HashStringList const &ExpectedHashes,
                                  indexRecords *MetaIndexParser)
    : pkgAcqBaseIndex(Owner, TransactionManager, Target, ExpectedHashes, 

-                     MetaIndexParser, Target->URI), 
-     PackagesFileReadyInPartial(false)
+                     MetaIndexParser), PackagesFileReadyInPartial(false)

 {
    
    Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
 
 {
    
    Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
 

+   RealURI = Target->URI;

    Desc.Owner = this;
    Desc.Owner = this;

-   Desc.Description = Target->Description + "/DiffIndex";
+   Desc.Description = Target->Description + ".diff/Index";

    Desc.ShortDesc = Target->ShortDesc;
    Desc.URI = Target->URI + ".diff/Index";
 
    Desc.ShortDesc = Target->ShortDesc;
    Desc.URI = Target->URI + ".diff/Index";
 

-   DestFile = _config->FindDir("Dir::State::lists") + "partial/";
-   DestFile += URItoFileName(Desc.URI);
+   DestFile = GetPartialFileNameFromURI(Desc.URI);

 
    if(Debug)
       std::clog << "pkgAcqDiffIndex: " << Desc.URI << std::endl;
 
    if(Debug)
       std::clog << "pkgAcqDiffIndex: " << Desc.URI << std::endl;


@@ -297,9 +350,7 @@ pkgAcqDiffIndex::pkgAcqDiffIndex(pkgAcquire *Owner,
       Desc.URI.substr(0,strlen("file:/")) == "file:/")
    {
       // we don't have a pkg file or we don't want to queue
       Desc.URI.substr(0,strlen("file:/")) == "file:/")
    {
       // we don't have a pkg file or we don't want to queue

-      if(Debug)
-        std::clog << "No index file, local or canceld by user" << std::endl;
-      Failed("", NULL);
+      Failed("No index file, local or canceld by user", NULL);

       return;
    }
 
       return;
    }
 


@@ -318,7 +369,7 @@ string pkgAcqDiffIndex::Custom600Headers() const
 {
    string Final = _config->FindDir("Dir::State::lists");
    Final += URItoFileName(Desc.URI);
 {
    string Final = _config->FindDir("Dir::State::lists");
    Final += URItoFileName(Desc.URI);

-   
+

    if(Debug)
       std::clog << "Custom600Header-IMS: " << Final << std::endl;
 
    if(Debug)
       std::clog << "Custom600Header-IMS: " << Final << std::endl;
 


@@ -331,182 +382,287 @@ string pkgAcqDiffIndex::Custom600Headers() const
                                                                        /*}}}*/
 bool pkgAcqDiffIndex::ParseDiffIndex(string IndexDiffFile)             /*{{{*/
 {
                                                                        /*}}}*/
 bool pkgAcqDiffIndex::ParseDiffIndex(string IndexDiffFile)             /*{{{*/
 {

+   // failing here is fine: our caller will take care of trying to
+   // get the complete file if patching fails

    if(Debug)
       std::clog << "pkgAcqDiffIndex::ParseIndexDiff() " << IndexDiffFile
         << std::endl;
 
    if(Debug)
       std::clog << "pkgAcqDiffIndex::ParseIndexDiff() " << IndexDiffFile
         << std::endl;
 

-   pkgTagSection Tags;
-   string ServerSha1;
-   vector<DiffInfo> available_patches;
-   

    FileFd Fd(IndexDiffFile,FileFd::ReadOnly);
    pkgTagFile TF(&Fd);
    if (_error->PendingError() == true)
       return false;
 
    FileFd Fd(IndexDiffFile,FileFd::ReadOnly);
    pkgTagFile TF(&Fd);
    if (_error->PendingError() == true)
       return false;
 

-   if(TF.Step(Tags) == true)
+   pkgTagSection Tags;
+   if(unlikely(TF.Step(Tags) == false))
+      return false;
+
+   HashStringList ServerHashes;
+   unsigned long long ServerSize = 0;
+
+   for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type)

    {
    {

-      bool found = false;
-      DiffInfo d;
-      string size;
+      std::string tagname = *type;
+      tagname.append("-Current");
+      std::string const tmp = Tags.FindS(tagname.c_str());
+      if (tmp.empty() == true)
+        continue;

 
 

-      string const tmp = Tags.FindS("SHA1-Current");
+      string hash;
+      unsigned long long size;

       std::stringstream ss(tmp);
       std::stringstream ss(tmp);

-      ss >> ServerSha1 >> size;
-      unsigned long const ServerSize = atol(size.c_str());
+      ss >> hash >> size;
+      if (unlikely(hash.empty() == true))
+        continue;
+      if (unlikely(ServerSize != 0 && ServerSize != size))
+        continue;
+      ServerHashes.push_back(HashString(*type, hash));
+      ServerSize = size;
+   }

 
 

-      FileFd fd(CurrentPackagesFile, FileFd::ReadOnly);
-      SHA1Summation SHA1;
-      SHA1.AddFD(fd);
-      string const local_sha1 = SHA1.Result();
+   if (ServerHashes.usable() == false)
+   {
+      if (Debug == true)
+        std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": Did not find a good hashsum in the index" << std::endl;
+      return false;
+   }

 
 

-      if(local_sha1 == ServerSha1)
+   if (ServerHashes != HashSums())
+   {
+      if (Debug == true)

       {
       {

-        // we have the same sha1 as the server so we are done here
-        if(Debug)
-           std::clog << "Package file is up-to-date" << std::endl;
-         // ensure we have no leftovers from previous runs
-         std::string Partial = _config->FindDir("Dir::State::lists");
-         Partial += "partial/" + URItoFileName(RealURI);
-         unlink(Partial.c_str());
-        // list cleanup needs to know that this file as well as the already
-        // present index is ours, so we create an empty diff to save it for us
-        new pkgAcqIndexDiffs(Owner, TransactionManager, Target, 
-                              ExpectedHashes, MetaIndexParser, 
-                              ServerSha1, available_patches);
-        return true;
+        std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": Index has different hashes than parser, probably older, so fail pdiffing" << std::endl;
+         printHashSumComparision(CurrentPackagesFile, ServerHashes, HashSums());

       }
       }

-      else
+      return false;
+   }
+
+   if (ServerHashes.VerifyFile(CurrentPackagesFile) == true)
+   {
+      // we have the same sha1 as the server so we are done here
+      if(Debug)
+        std::clog << "pkgAcqDiffIndex: Package file " << CurrentPackagesFile << " is up-to-date" << std::endl;
+
+      // list cleanup needs to know that this file as well as the already
+      // present index is ours, so we create an empty diff to save it for us
+      new pkgAcqIndexDiffs(Owner, TransactionManager, Target,
+                           ExpectedHashes, MetaIndexParser);
+      return true;
+   }
+
+   FileFd fd(CurrentPackagesFile, FileFd::ReadOnly);
+   Hashes LocalHashesCalc;
+   LocalHashesCalc.AddFD(fd);
+   HashStringList const LocalHashes = LocalHashesCalc.GetHashStringList();
+
+   if(Debug)
+      std::clog << "Server-Current: " << ServerHashes.find(NULL)->toStr() << " and we start at "
+        << fd.Name() << " " << fd.FileSize() << " " << LocalHashes.find(NULL)->toStr() << std::endl;
+
+   // parse all of (provided) history
+   vector<DiffInfo> available_patches;
+   bool firstAcceptedHashes = true;
+   for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type)
+   {
+      if (LocalHashes.find(*type) == NULL)
+        continue;
+
+      std::string tagname = *type;
+      tagname.append("-History");
+      std::string const tmp = Tags.FindS(tagname.c_str());
+      if (tmp.empty() == true)
+        continue;
+
+      string hash, filename;
+      unsigned long long size;
+      std::stringstream ss(tmp);
+
+      while (ss >> hash >> size >> filename)

       {
       {

-        if(Debug)
-           std::clog << "SHA1-Current: " << ServerSha1 << " and we start at "<< fd.Name() << " " << fd.Size() << " " << local_sha1 << std::endl;
+        if (unlikely(hash.empty() == true || filename.empty() == true))
+           continue;

 
 

-        // check the historie and see what patches we need
-        string const history = Tags.FindS("SHA1-History");
-        std::stringstream hist(history);
-        while(hist >> d.sha1 >> size >> d.file)
+        // see if we have a record for this file already
+        std::vector<DiffInfo>::iterator cur = available_patches.begin();
+        for (; cur != available_patches.end(); ++cur)

         {
         {

-           // read until the first match is found
-           // from that point on, we probably need all diffs
-           if(d.sha1 == local_sha1) 
-              found=true;
-           else if (found == false)
+           if (cur->file != filename || unlikely(cur->result_size != size))

               continue;
               continue;

-
-           if(Debug)
-              std::clog << "Need to get diff: " << d.file << std::endl;
-           available_patches.push_back(d);
+           cur->result_hashes.push_back(HashString(*type, hash));
+           break;

         }
         }

-
-        if (available_patches.empty() == false)
+        if (cur != available_patches.end())
+           continue;
+        if (firstAcceptedHashes == true)
+        {
+           DiffInfo next;
+           next.file = filename;
+           next.result_hashes.push_back(HashString(*type, hash));
+           next.result_size = size;
+           next.patch_size = 0;
+           available_patches.push_back(next);
+        }
+        else

         {
         {

-           // patching with too many files is rather slow compared to a fast download
-           unsigned long const fileLimit = _config->FindI("Acquire::PDiffs::FileLimit", 0);
-           if (fileLimit != 0 && fileLimit < available_patches.size())
-           {
-              if (Debug)
-                 std::clog << "Need " << available_patches.size() << " diffs (Limit is " << fileLimit
-                       << ") so fallback to complete download" << std::endl;
-              return false;
-           }
-
-           // see if the patches are too big
-           found = false; // it was true and it will be true again at the end
-           d = *available_patches.begin();
-           string const firstPatch = d.file;
-           unsigned long patchesSize = 0;
-           std::stringstream patches(Tags.FindS("SHA1-Patches"));
-           while(patches >> d.sha1 >> size >> d.file)
-           {
-              if (firstPatch == d.file)
-                 found = true;
-              else if (found == false)
-                 continue;
-
-              patchesSize += atol(size.c_str());
-           }
-           unsigned long const sizeLimit = ServerSize * _config->FindI("Acquire::PDiffs::SizeLimit", 100);
-           if (sizeLimit > 0 && (sizeLimit/100) < patchesSize)
-           {
-              if (Debug)
-                 std::clog << "Need " << patchesSize << " bytes (Limit is " << sizeLimit/100
-                       << ") so fallback to complete download" << std::endl;
-              return false;
-           }
+           if (Debug == true)
+              std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": File " << filename
+                 << " wasn't in the list for the first parsed hash! (history)" << std::endl;
+           break;

         }
       }
         }
       }

+      firstAcceptedHashes = false;
+   }
+
+   if (unlikely(available_patches.empty() == true))
+   {
+      if (Debug)
+        std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": "
+           << "Couldn't find any patches for the patch series." << std::endl;
+      return false;
+   }

 
 

-      // we have something, queue the next diff
-      if(found)
+   for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type)
+   {
+      if (LocalHashes.find(*type) == NULL)
+        continue;
+
+      std::string tagname = *type;
+      tagname.append("-Patches");
+      std::string const tmp = Tags.FindS(tagname.c_str());
+      if (tmp.empty() == true)
+        continue;
+
+      string hash, filename;
+      unsigned long long size;
+      std::stringstream ss(tmp);
+
+      while (ss >> hash >> size >> filename)

       {
       {

-         // FIXME: make this use the method
-         PackagesFileReadyInPartial = true;
-         std::string Partial = _config->FindDir("Dir::State::lists");
-         Partial += "partial/" + URItoFileName(RealURI);
-
-         FileFd From(CurrentPackagesFile, FileFd::ReadOnly);
-         FileFd To(Partial, FileFd::WriteEmpty);
-         if(CopyFile(From, To) == false)
-            return _error->Errno("CopyFile", "failed to copy");
-
-         if(Debug)
-            std::cerr << "Done copying " << CurrentPackagesFile
-                      << " -> " << Partial
-                      << std::endl;
+        if (unlikely(hash.empty() == true || filename.empty() == true))
+           continue;

 
 

-        // queue the diffs
-        string::size_type const last_space = Description.rfind(" ");
-        if(last_space != string::npos)
-           Description.erase(last_space, Description.size()-last_space);
-
-        /* decide if we should download patches one by one or in one go:
-           The first is good if the server merges patches, but many don't so client
-           based merging can be attempt in which case the second is better.
-           "bad things" will happen if patches are merged on the server,
-           but client side merging is attempt as well */
-        bool pdiff_merge = _config->FindB("Acquire::PDiffs::Merge", true);
-        if (pdiff_merge == true)
+        // see if we have a record for this file already
+        std::vector<DiffInfo>::iterator cur = available_patches.begin();
+        for (; cur != available_patches.end(); ++cur)

         {
         {

-           // reprepro adds this flag if it has merged patches on the server
-           std::string const precedence = Tags.FindS("X-Patch-Precedence");
-           pdiff_merge = (precedence != "merged");
+           if (cur->file != filename)
+              continue;
+           if (unlikely(cur->patch_size != 0 && cur->patch_size != size))
+              continue;
+           cur->patch_hashes.push_back(HashString(*type, hash));
+           cur->patch_size = size;
+           break;

         }
         }

+        if (cur != available_patches.end())
+              continue;
+        if (Debug == true)
+           std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": File " << filename
+              << " wasn't in the list for the first parsed hash! (patches)" << std::endl;
+        break;
+      }
+   }

 
 

-        if (pdiff_merge == false)
-         {
-           new pkgAcqIndexDiffs(Owner, TransactionManager, Target, ExpectedHashes, 
-                                 MetaIndexParser,
-                                 ServerSha1, available_patches);
-         }
-         else
-        {
-           std::vector<pkgAcqIndexMergeDiffs*> *diffs = new std::vector<pkgAcqIndexMergeDiffs*>(available_patches.size());
-           for(size_t i = 0; i < available_patches.size(); ++i)
-              (*diffs)[i] = new pkgAcqIndexMergeDiffs(Owner,
-                                                       TransactionManager,
-                                                       Target,
-                                                       ExpectedHashes,
-                                                       MetaIndexParser,
-                                                       available_patches[i],
-                                                       diffs);
-        }
+   bool foundStart = false;
+   for (std::vector<DiffInfo>::iterator cur = available_patches.begin();
+        cur != available_patches.end(); ++cur)
+   {
+      if (LocalHashes != cur->result_hashes)
+        continue;

 
 

-         Complete = false;
-         Status = StatDone;
-         Dequeue();
-         return true;
-      }
+      available_patches.erase(available_patches.begin(), cur);
+      foundStart = true;
+      break;
+   }
+
+   if (foundStart == false || unlikely(available_patches.empty() == true))
+   {
+      if (Debug)
+        std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": "
+           << "Couldn't find the start of the patch series." << std::endl;
+      return false;
+   }
+
+   // patching with too many files is rather slow compared to a fast download
+   unsigned long const fileLimit = _config->FindI("Acquire::PDiffs::FileLimit", 0);
+   if (fileLimit != 0 && fileLimit < available_patches.size())
+   {
+      if (Debug)
+        std::clog << "Need " << available_patches.size() << " diffs (Limit is " << fileLimit
+           << ") so fallback to complete download" << std::endl;
+      return false;
+   }
+
+   // calculate the size of all patches we have to get
+   // note that all sizes are uncompressed, while we download compressed files
+   unsigned long long patchesSize = 0;
+   for (std::vector<DiffInfo>::const_iterator cur = available_patches.begin();
+        cur != available_patches.end(); ++cur)
+      patchesSize += cur->patch_size;
+   unsigned long long const sizeLimit = ServerSize * _config->FindI("Acquire::PDiffs::SizeLimit", 100);
+   if (false && sizeLimit > 0 && (sizeLimit/100) < patchesSize)
+   {
+      if (Debug)
+        std::clog << "Need " << patchesSize << " bytes (Limit is " << sizeLimit/100
+           << ") so fallback to complete download" << std::endl;
+      return false;

    }
    }

+
+   // FIXME: make this use the method
+   PackagesFileReadyInPartial = true;
+   std::string const Partial = GetPartialFileNameFromURI(RealURI);
+   
+   FileFd From(CurrentPackagesFile, FileFd::ReadOnly);
+   FileFd To(Partial, FileFd::WriteEmpty);
+   if(CopyFile(From, To) == false)
+      return _error->Errno("CopyFile", "failed to copy");

    
    

-   // Nothing found, report and return false
-   // Failing here is ok, if we return false later, the full
-   // IndexFile is queued

    if(Debug)
    if(Debug)

-      std::clog << "Can't find a patch in the index file" << std::endl;
-   return false;
+      std::cerr << "Done copying " << CurrentPackagesFile
+                << " -> " << Partial
+                << std::endl;
+
+   // we have something, queue the diffs
+   string::size_type const last_space = Description.rfind(" ");
+   if(last_space != string::npos)
+      Description.erase(last_space, Description.size()-last_space);
+
+   /* decide if we should download patches one by one or in one go:
+      The first is good if the server merges patches, but many don't so client
+      based merging can be attempt in which case the second is better.
+      "bad things" will happen if patches are merged on the server,
+      but client side merging is attempt as well */
+   bool pdiff_merge = _config->FindB("Acquire::PDiffs::Merge", true);
+   if (pdiff_merge == true)
+   {
+      // reprepro adds this flag if it has merged patches on the server
+      std::string const precedence = Tags.FindS("X-Patch-Precedence");
+      pdiff_merge = (precedence != "merged");
+   }
+
+   if (pdiff_merge == false)
+   {
+      new pkgAcqIndexDiffs(Owner, TransactionManager, Target, ExpectedHashes, 
+                           MetaIndexParser, available_patches);
+   }
+   else
+   {
+      std::vector<pkgAcqIndexMergeDiffs*> *diffs = new std::vector<pkgAcqIndexMergeDiffs*>(available_patches.size());
+      for(size_t i = 0; i < available_patches.size(); ++i)
+        (*diffs)[i] = new pkgAcqIndexMergeDiffs(Owner, TransactionManager,
+               Target,
+              ExpectedHashes,
+              MetaIndexParser,
+              available_patches[i],
+              diffs);
+   }
+
+   Complete = false;
+   Status = StatDone;
+   Dequeue();
+   return true;

 }
                                                                        /*}}}*/
 }
                                                                        /*}}}*/

-void pkgAcqDiffIndex::Failed(string Message,pkgAcquire::MethodConfig * /*Cnf*/)/*{{{*/
+void pkgAcqDiffIndex::Failed(string Message,pkgAcquire::MethodConfig * Cnf)/*{{{*/

 {
    if(Debug)
       std::clog << "pkgAcqDiffIndex failed: " << Desc.URI << " with " << Message << std::endl
 {
    if(Debug)
       std::clog << "pkgAcqDiffIndex failed: " << Desc.URI << " with " << Message << std::endl


@@ -514,9 +670,8 @@ void pkgAcqDiffIndex::Failed(string Message,pkgAcquire::MethodConfig * /*Cnf*/)/
 
    new pkgAcqIndex(Owner, TransactionManager, Target, ExpectedHashes, MetaIndexParser);
 
 
    new pkgAcqIndex(Owner, TransactionManager, Target, ExpectedHashes, MetaIndexParser);
 

-   Complete = false;
+   Item::Failed(Message,Cnf);

    Status = StatDone;
    Status = StatDone;

-   Dequeue();

 }
                                                                        /*}}}*/
 void pkgAcqDiffIndex::Done(string Message,unsigned long long Size,HashStringList const &Hashes,        /*{{{*/
 }
                                                                        /*}}}*/
 void pkgAcqDiffIndex::Done(string Message,unsigned long long Size,HashStringList const &Hashes,        /*{{{*/


@@ -543,20 +698,17 @@ void pkgAcqDiffIndex::Done(string Message,unsigned long long Size,HashStringList
    }
 
    string FinalFile;
    }
 
    string FinalFile;

-   FinalFile = _config->FindDir("Dir::State::lists")+URItoFileName(RealURI);
+   FinalFile = _config->FindDir("Dir::State::lists");
+   FinalFile += URItoFileName(Desc.URI);

 
 

-   // success in downloading the index
-   // rename the index
-   FinalFile += string(".IndexDiff");
-   if(Debug)
-      std::clog << "Renaming: " << DestFile << " -> " << FinalFile 
-               << std::endl;
-   Rename(DestFile,FinalFile);
-   chmod(FinalFile.c_str(),0644);
-   DestFile = FinalFile;
+   if(StringToBool(LookupTag(Message,"IMS-Hit"),false))
+      DestFile = FinalFile;

 
    if(!ParseDiffIndex(DestFile))
 
    if(!ParseDiffIndex(DestFile))

-      return Failed("", NULL);
+      return Failed("Message: Couldn't parse pdiff index", Cnf);
+
+   // queue for final move
+   TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);

 
    Complete = true;
    Status = StatDone;
 
    Complete = true;
    Status = StatDone;


@@ -574,18 +726,15 @@ pkgAcqIndexDiffs::pkgAcqIndexDiffs(pkgAcquire *Owner,
                                    struct IndexTarget const * const Target,
                                    HashStringList const &ExpectedHashes,
                                    indexRecords *MetaIndexParser,
                                    struct IndexTarget const * const Target,
                                    HashStringList const &ExpectedHashes,
                                    indexRecords *MetaIndexParser,

-                                  string ServerSha1,

                                   vector<DiffInfo> diffs)
                                   vector<DiffInfo> diffs)

-   : pkgAcqBaseIndex(Owner, TransactionManager, Target, ExpectedHashes, 
-                     MetaIndexParser, Target->URI),
-     available_patches(diffs), ServerSha1(ServerSha1)
+   : pkgAcqBaseIndex(Owner, TransactionManager, Target, ExpectedHashes, MetaIndexParser),
+     available_patches(diffs)

 {
 {

-   
-   DestFile = _config->FindDir("Dir::State::lists") + "partial/";
-   DestFile += URItoFileName(Target->URI);
+   DestFile = GetPartialFileNameFromURI(Target->URI);

 
    Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
 
 
    Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
 

+   RealURI = Target->URI;

    Desc.Owner = this;
    Description = Target->Description;
    Desc.ShortDesc = Target->ShortDesc;
    Desc.Owner = this;
    Description = Target->Description;
    Desc.ShortDesc = Target->ShortDesc;


@@ -634,16 +783,9 @@ void pkgAcqIndexDiffs::Finish(bool allDone)
       }
 
       // queue for copy
       }
 
       // queue for copy

-      PartialFile = _config->FindDir("Dir::State::lists")+"partial/"+URItoFileName(RealURI);
-
-      DestFile = _config->FindDir("Dir::State::lists");
-      DestFile += URItoFileName(RealURI);
-
-      // this happens if we have a up-to-date indexfile
-      if(!FileExists(PartialFile))
-         PartialFile = DestFile;
-
-      TransactionManager->TransactionStageCopy(this, PartialFile, DestFile);
+      std::string FinalFile = _config->FindDir("Dir::State::lists");
+      FinalFile += URItoFileName(RealURI);
+      TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);

 
       // this is for the "real" finish
       Complete = true;
 
       // this is for the "real" finish
       Complete = true;


@@ -665,26 +807,31 @@ void pkgAcqIndexDiffs::Finish(bool allDone)
 bool pkgAcqIndexDiffs::QueueNextDiff()                                 /*{{{*/
 {
    // calc sha1 of the just patched file
 bool pkgAcqIndexDiffs::QueueNextDiff()                                 /*{{{*/
 {
    // calc sha1 of the just patched file

-   string FinalFile = _config->FindDir("Dir::State::lists");
-   FinalFile += "partial/" + URItoFileName(RealURI);
+   std::string const FinalFile = GetPartialFileNameFromURI(RealURI);

 
    if(!FileExists(FinalFile))
    {
 
    if(!FileExists(FinalFile))
    {

-      Failed("No FinalFile " + FinalFile + " available", NULL);
+      Failed("Message: No FinalFile " + FinalFile + " available", NULL);

       return false;
    }
 
    FileFd fd(FinalFile, FileFd::ReadOnly);
       return false;
    }
 
    FileFd fd(FinalFile, FileFd::ReadOnly);

-   SHA1Summation SHA1;
-   SHA1.AddFD(fd);
-   string local_sha1 = string(SHA1.Result());
+   Hashes LocalHashesCalc;
+   LocalHashesCalc.AddFD(fd);
+   HashStringList const LocalHashes = LocalHashesCalc.GetHashStringList();
+

    if(Debug)
    if(Debug)

-      std::clog << "QueueNextDiff: " 
-               << FinalFile << " (" << local_sha1 << ")"<<std::endl;
+      std::clog << "QueueNextDiff: " << FinalFile << " (" << LocalHashes.find(NULL)->toStr() << ")" << std::endl;
+
+   if (unlikely(LocalHashes.usable() == false || ExpectedHashes.usable() == false))
+   {
+      Failed("Local/Expected hashes are not usable", NULL);
+      return false;
+   }

 
 
    // final file reached before all patches are applied
 
 
    // final file reached before all patches are applied

-   if(local_sha1 == ServerSha1)
+   if(LocalHashes == ExpectedHashes)

    {
       Finish(true);
       return true;
    {
       Finish(true);
       return true;


@@ -692,10 +839,10 @@ bool pkgAcqIndexDiffs::QueueNextDiff()                                    /*{{{*/
 
    // remove all patches until the next matching patch is found
    // this requires the Index file to be ordered
 
    // remove all patches until the next matching patch is found
    // this requires the Index file to be ordered

-   for(vector<DiffInfo>::iterator I=available_patches.begin();
+   for(vector<DiffInfo>::iterator I = available_patches.begin();

        available_patches.empty() == false &&
          I != available_patches.end() &&
        available_patches.empty() == false &&
          I != available_patches.end() &&

-         I->sha1 != local_sha1;
+         I->result_hashes != LocalHashes;

        ++I)
    {
       available_patches.erase(I);
        ++I)
    {
       available_patches.erase(I);


@@ -704,19 +851,18 @@ bool pkgAcqIndexDiffs::QueueNextDiff()                                    /*{{{*/
    // error checking and falling back if no patch was found
    if(available_patches.empty() == true)
    {
    // error checking and falling back if no patch was found
    if(available_patches.empty() == true)
    {

-      Failed("No patches available", NULL);
+      Failed("No patches left to reach target", NULL);

       return false;
    }
 
    // queue the right diff
    Desc.URI = RealURI + ".diff/" + available_patches[0].file + ".gz";
    Desc.Description = Description + " " + available_patches[0].file + string(".pdiff");
       return false;
    }
 
    // queue the right diff
    Desc.URI = RealURI + ".diff/" + available_patches[0].file + ".gz";
    Desc.Description = Description + " " + available_patches[0].file + string(".pdiff");

-   DestFile = _config->FindDir("Dir::State::lists") + "partial/";
-   DestFile += URItoFileName(RealURI + ".diff/" + available_patches[0].file);
+   DestFile = GetPartialFileNameFromURI(RealURI + ".diff/" + available_patches[0].file);

 
    if(Debug)
       std::clog << "pkgAcqIndexDiffs::QueueNextDiff(): " << Desc.URI << std::endl;
 
    if(Debug)
       std::clog << "pkgAcqIndexDiffs::QueueNextDiff(): " << Desc.URI << std::endl;

-   
+

    QueueURI(Desc);
 
    return true;
    QueueURI(Desc);
 
    return true;


@@ -731,13 +877,22 @@ void pkgAcqIndexDiffs::Done(string Message,unsigned long long Size, HashStringLi
    Item::Done(Message, Size, Hashes, Cnf);
 
    // FIXME: verify this download too before feeding it to rred
    Item::Done(Message, Size, Hashes, Cnf);
 
    // FIXME: verify this download too before feeding it to rred

-
-   string FinalFile;
-   FinalFile = _config->FindDir("Dir::State::lists")+"partial/"+URItoFileName(RealURI);
+   std::string const FinalFile = GetPartialFileNameFromURI(RealURI);

 
    // success in downloading a diff, enter ApplyDiff state
    if(State == StateFetchDiff)
    {
 
    // success in downloading a diff, enter ApplyDiff state
    if(State == StateFetchDiff)
    {

+      FileFd fd(DestFile, FileFd::ReadOnly, FileFd::Gzip);
+      class Hashes LocalHashesCalc;
+      LocalHashesCalc.AddFD(fd);
+      HashStringList const LocalHashes = LocalHashesCalc.GetHashStringList();
+
+      if (fd.Size() != available_patches[0].patch_size ||
+           available_patches[0].patch_hashes != LocalHashes)
+      {
+        Failed("Patch has Size/Hashsum mismatch", NULL);
+        return;
+      }

 
       // rred excepts the patch as $FinalFile.ed
       Rename(DestFile,FinalFile+".ed");
 
       // rred excepts the patch as $FinalFile.ed
       Rename(DestFile,FinalFile+".ed");


@@ -749,15 +904,7 @@ void pkgAcqIndexDiffs::Done(string Message,unsigned long long Size, HashStringLi
       Local = true;
       Desc.URI = "rred:" + FinalFile;
       QueueURI(Desc);
       Local = true;
       Desc.URI = "rred:" + FinalFile;
       QueueURI(Desc);

-      ActiveSubprocess = "rred";
-#if __GNUC__ >= 4
-       #pragma GCC diagnostic push
-       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-      Mode = "rred";
-#if __GNUC__ >= 4
-       #pragma GCC diagnostic pop
-#endif
+      SetActiveSubprocess("rred");

       return;
    } 
 
       return;
    } 
 


@@ -782,7 +929,7 @@ void pkgAcqIndexDiffs::Done(string Message,unsigned long long Size, HashStringLi
       if(available_patches.empty() == false) {
         new pkgAcqIndexDiffs(Owner, TransactionManager, Target,
                              ExpectedHashes, MetaIndexParser,
       if(available_patches.empty() == false) {
         new pkgAcqIndexDiffs(Owner, TransactionManager, Target,
                              ExpectedHashes, MetaIndexParser,

-                              ServerSha1, available_patches);
+                             available_patches);

         return Finish();
       } else 
          // update
         return Finish();
       } else 
          // update


@@ -799,24 +946,20 @@ pkgAcqIndexMergeDiffs::pkgAcqIndexMergeDiffs(pkgAcquire *Owner,
                                              indexRecords *MetaIndexParser,
                                              DiffInfo const &patch,
                                              std::vector<pkgAcqIndexMergeDiffs*> const * const allPatches)
                                              indexRecords *MetaIndexParser,
                                              DiffInfo const &patch,
                                              std::vector<pkgAcqIndexMergeDiffs*> const * const allPatches)

-  : pkgAcqBaseIndex(Owner, TransactionManager, Target, ExpectedHashes, 
-                    MetaIndexParser, Target->URI),
+  : pkgAcqBaseIndex(Owner, TransactionManager, Target, ExpectedHashes, MetaIndexParser),

      patch(patch), allPatches(allPatches), State(StateFetchDiff)
 {
      patch(patch), allPatches(allPatches), State(StateFetchDiff)
 {

-
-   DestFile = _config->FindDir("Dir::State::lists") + "partial/";
-   DestFile += URItoFileName(Target->URI);
-

    Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
 
    Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
 

+   RealURI = Target->URI;

    Desc.Owner = this;
    Description = Target->Description;
    Desc.ShortDesc = Target->ShortDesc;
 
    Desc.URI = RealURI + ".diff/" + patch.file + ".gz";
    Desc.Description = Description + " " + patch.file + string(".pdiff");
    Desc.Owner = this;
    Description = Target->Description;
    Desc.ShortDesc = Target->ShortDesc;
 
    Desc.URI = RealURI + ".diff/" + patch.file + ".gz";
    Desc.Description = Description + " " + patch.file + string(".pdiff");

-   DestFile = _config->FindDir("Dir::State::lists") + "partial/";
-   DestFile += URItoFileName(RealURI + ".diff/" + patch.file);
+
+   DestFile = GetPartialFileNameFromURI(RealURI + ".diff/" + patch.file);

 
    if(Debug)
       std::clog << "pkgAcqIndexMergeDiffs: " << Desc.URI << std::endl;
 
    if(Debug)
       std::clog << "pkgAcqIndexMergeDiffs: " << Desc.URI << std::endl;


@@ -824,13 +967,13 @@ pkgAcqIndexMergeDiffs::pkgAcqIndexMergeDiffs(pkgAcquire *Owner,
    QueueURI(Desc);
 }
                                                                        /*}}}*/
    QueueURI(Desc);
 }
                                                                        /*}}}*/

-void pkgAcqIndexMergeDiffs::Failed(string Message,pkgAcquire::MethodConfig * /*Cnf*/)/*{{{*/
+void pkgAcqIndexMergeDiffs::Failed(string Message,pkgAcquire::MethodConfig * Cnf)/*{{{*/

 {
    if(Debug)
       std::clog << "pkgAcqIndexMergeDiffs failed: " << Desc.URI << " with " << Message << std::endl;
 {
    if(Debug)
       std::clog << "pkgAcqIndexMergeDiffs failed: " << Desc.URI << " with " << Message << std::endl;

-   Complete = false;
+
+   Item::Failed(Message,Cnf);

    Status = StatDone;
    Status = StatDone;

-   Dequeue();

 
    // check if we are the first to fail, otherwise we are done here
    State = StateDoneDiff;
 
    // check if we are the first to fail, otherwise we are done here
    State = StateDoneDiff;


@@ -854,11 +997,21 @@ void pkgAcqIndexMergeDiffs::Done(string Message,unsigned long long Size,HashStri
    Item::Done(Message,Size,Hashes,Cnf);
 
    // FIXME: verify download before feeding it to rred
    Item::Done(Message,Size,Hashes,Cnf);
 
    // FIXME: verify download before feeding it to rred

-
-   string const FinalFile = _config->FindDir("Dir::State::lists") + "partial/" + URItoFileName(RealURI);
+   string const FinalFile = GetPartialFileNameFromURI(RealURI);

 
    if (State == StateFetchDiff)
    {
 
    if (State == StateFetchDiff)
    {

+      FileFd fd(DestFile, FileFd::ReadOnly, FileFd::Gzip);
+      class Hashes LocalHashesCalc;
+      LocalHashesCalc.AddFD(fd);
+      HashStringList const LocalHashes = LocalHashesCalc.GetHashStringList();
+
+      if (fd.Size() != patch.patch_size || patch.patch_hashes != LocalHashes)
+      {
+        Failed("Patch has Size/Hashsum mismatch", NULL);
+        return;
+      }
+

       // rred expects the patch as $FinalFile.ed.$patchname.gz
       Rename(DestFile, FinalFile + ".ed." + patch.file + ".gz");
 
       // rred expects the patch as $FinalFile.ed.$patchname.gz
       Rename(DestFile, FinalFile + ".ed." + patch.file + ".gz");
 


@@ -882,15 +1035,7 @@ void pkgAcqIndexMergeDiffs::Done(string Message,unsigned long long Size,HashStri
       Local = true;
       Desc.URI = "rred:" + FinalFile;
       QueueURI(Desc);
       Local = true;
       Desc.URI = "rred:" + FinalFile;
       QueueURI(Desc);

-      ActiveSubprocess = "rred";
-#if __GNUC__ >= 4
-       #pragma GCC diagnostic push
-       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-      Mode = "rred";
-#if __GNUC__ >= 4
-       #pragma GCC diagnostic pop
-#endif
+      SetActiveSubprocess("rred");

       return;
    }
    // success in download/apply all diffs, clean up
       return;
    }
    // success in download/apply all diffs, clean up


@@ -919,8 +1064,7 @@ void pkgAcqIndexMergeDiffs::Done(string Message,unsigned long long Size,HashStri
       for (std::vector<pkgAcqIndexMergeDiffs *>::const_iterator I = allPatches->begin();
            I != allPatches->end(); ++I)
       {
       for (std::vector<pkgAcqIndexMergeDiffs *>::const_iterator I = allPatches->begin();
            I != allPatches->end(); ++I)
       {

-            std::string PartialFile = _config->FindDir("Dir::State::lists");
-            PartialFile += "partial/" + URItoFileName(RealURI);
+            std::string const PartialFile = GetPartialFileNameFromURI(RealURI);

            std::string patch = PartialFile + ".ed." + (*I)->patch.file + ".gz";
             std::cerr << patch << std::endl;
            unlink(patch.c_str());
            std::string patch = PartialFile + ".ed." + (*I)->patch.file + ".gz";
             std::cerr << patch << std::endl;
            unlink(patch.c_str());


@@ -933,7 +1077,6 @@ void pkgAcqIndexMergeDiffs::Done(string Message,unsigned long long Size,HashStri
    }
 }
                                                                        /*}}}*/
    }
 }
                                                                        /*}}}*/

-

 // AcqBaseIndex::VerifyHashByMetaKey - verify hash for the given metakey /*{{{*/
 bool pkgAcqBaseIndex::VerifyHashByMetaKey(HashStringList const &Hashes)
 {
 // AcqBaseIndex::VerifyHashByMetaKey - verify hash for the given metakey /*{{{*/
 bool pkgAcqBaseIndex::VerifyHashByMetaKey(HashStringList const &Hashes)
 {


@@ -948,17 +1091,18 @@ bool pkgAcqBaseIndex::VerifyHashByMetaKey(HashStringList const &Hashes)
    }
    return true;
 }
    }
    return true;
 }

-
-
+                                                                       /*}}}*/

 // AcqIndex::AcqIndex - Constructor                                    /*{{{*/
 // ---------------------------------------------------------------------
 // AcqIndex::AcqIndex - Constructor                                    /*{{{*/
 // ---------------------------------------------------------------------

-/* The package file is added to the queue and a second class is 
-   instantiated to fetch the revision file */   
+/* The package file is added to the queue and a second class is
+   instantiated to fetch the revision file */

 pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,
                         string URI,string URIDesc,string ShortDesc,
                         HashStringList const  &ExpectedHash)
 pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,
                         string URI,string URIDesc,string ShortDesc,
                         HashStringList const  &ExpectedHash)

-   : pkgAcqBaseIndex(Owner, 0, NULL, ExpectedHash, NULL, RealURI)
+   : pkgAcqBaseIndex(Owner, 0, NULL, ExpectedHash, NULL)

 {
 {

+   RealURI = URI;
+

    AutoSelectCompression();
    Init(URI, URIDesc, ShortDesc);
 
    AutoSelectCompression();
    Init(URI, URIDesc, ShortDesc);
 


@@ -968,15 +1112,16 @@ pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,
 }
                                                                        /*}}}*/
 // AcqIndex::AcqIndex - Constructor                                    /*{{{*/
 }
                                                                        /*}}}*/
 // AcqIndex::AcqIndex - Constructor                                    /*{{{*/

-// ---------------------------------------------------------------------

 pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,
                          pkgAcqMetaBase *TransactionManager,
                          IndexTarget const *Target,
 pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,
                          pkgAcqMetaBase *TransactionManager,
                          IndexTarget const *Target,

-                        HashStringList const &ExpectedHash, 
+                        HashStringList const &ExpectedHash,

                          indexRecords *MetaIndexParser)
                          indexRecords *MetaIndexParser)

-   : pkgAcqBaseIndex(Owner, TransactionManager, Target, ExpectedHash, 
-                     MetaIndexParser, Target->URI)
+   : pkgAcqBaseIndex(Owner, TransactionManager, Target, ExpectedHash,
+                     MetaIndexParser)

 {
 {

+   RealURI = Target->URI;
+

    // autoselect the compression method
    AutoSelectCompression();
    Init(Target->URI, Target->Description, Target->ShortDesc);
    // autoselect the compression method
    AutoSelectCompression();
    Init(Target->URI, Target->Description, Target->ShortDesc);


@@ -987,7 +1132,6 @@ pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,
 }
                                                                        /*}}}*/
 // AcqIndex::AutoSelectCompression - Select compression                        /*{{{*/
 }
                                                                        /*}}}*/
 // AcqIndex::AutoSelectCompression - Select compression                        /*{{{*/

-// ---------------------------------------------------------------------

 void pkgAcqIndex::AutoSelectCompression()
 {
    std::vector<std::string> types = APT::Configuration::getCompressionTypes();
 void pkgAcqIndex::AutoSelectCompression()
 {
    std::vector<std::string> types = APT::Configuration::getCompressionTypes();


@@ -998,7 +1142,7 @@ void pkgAcqIndex::AutoSelectCompression()
            t != types.end(); ++t)
       {
          std::string CompressedMetaKey = string(Target->MetaKey).append(".").append(*t);
            t != types.end(); ++t)
       {
          std::string CompressedMetaKey = string(Target->MetaKey).append(".").append(*t);

-         if (*t == "uncompressed" || 
+         if (*t == "uncompressed" ||

              MetaIndexParser->Exists(CompressedMetaKey) == true)
             CompressionExtensions.append(*t).append(" ");
       }
              MetaIndexParser->Exists(CompressedMetaKey) == true)
             CompressionExtensions.append(*t).append(" ");
       }


@@ -1011,15 +1155,14 @@ void pkgAcqIndex::AutoSelectCompression()
    if (CompressionExtensions.empty() == false)
       CompressionExtensions.erase(CompressionExtensions.end()-1);
 }
    if (CompressionExtensions.empty() == false)
       CompressionExtensions.erase(CompressionExtensions.end()-1);
 }

+                                                                       /*}}}*/

 // AcqIndex::Init - defered Constructor                                        /*{{{*/
 // AcqIndex::Init - defered Constructor                                        /*{{{*/

-// ---------------------------------------------------------------------
-void pkgAcqIndex::Init(string const &URI, string const &URIDesc, 
+void pkgAcqIndex::Init(string const &URI, string const &URIDesc,

                        string const &ShortDesc)
 {
    Stage = STAGE_DOWNLOAD;
 
                        string const &ShortDesc)
 {
    Stage = STAGE_DOWNLOAD;
 

-   DestFile = _config->FindDir("Dir::State::lists") + "partial/";
-   DestFile += URItoFileName(URI);
+   DestFile = GetPartialFileNameFromURI(URI);

 
    CurrentCompressionExtension = CompressionExtensions.substr(0, CompressionExtensions.find(' '));
    if (CurrentCompressionExtension == "uncompressed")
 
    CurrentCompressionExtension = CompressionExtensions.substr(0, CompressionExtensions.find(' '));
    if (CurrentCompressionExtension == "uncompressed")


@@ -1042,7 +1185,7 @@ void pkgAcqIndex::Init(string const &URI, string const &URIDesc,
       indexRecords::checkSum *Record = MetaIndexParser->Lookup(MetaKey);
       if(Record)
          FileSize = Record->Size;
       indexRecords::checkSum *Record = MetaIndexParser->Lookup(MetaKey);
       if(Record)
          FileSize = Record->Size;

-      
+

       InitByHashIfNeeded(MetaKey);
    }
 
       InitByHashIfNeeded(MetaKey);
    }
 


@@ -1054,8 +1197,6 @@ void pkgAcqIndex::Init(string const &URI, string const &URIDesc,
 }
                                                                        /*}}}*/
 // AcqIndex::AdjustForByHash - modify URI for by-hash support          /*{{{*/
 }
                                                                        /*}}}*/
 // AcqIndex::AdjustForByHash - modify URI for by-hash support          /*{{{*/

-// ---------------------------------------------------------------------
-/* */

 void pkgAcqIndex::InitByHashIfNeeded(const std::string MetaKey)
 {
    // TODO:
 void pkgAcqIndex::InitByHashIfNeeded(const std::string MetaKey)
 {
    // TODO:


@@ -1091,7 +1232,7 @@ void pkgAcqIndex::InitByHashIfNeeded(const std::string MetaKey)
 string pkgAcqIndex::Custom600Headers() const
 {
    string Final = GetFinalFilename();
 string pkgAcqIndex::Custom600Headers() const
 {
    string Final = GetFinalFilename();

-   
+

    string msg = "\nIndex-File: true";
    struct stat Buf;
    if (stat(Final.c_str(),&Buf) == 0)
    string msg = "\nIndex-File: true";
    struct stat Buf;
    if (stat(Final.c_str(),&Buf) == 0)


@@ -1100,10 +1241,8 @@ string pkgAcqIndex::Custom600Headers() const
    return msg;
 }
                                                                        /*}}}*/
    return msg;
 }
                                                                        /*}}}*/

-// pkgAcqIndex::Failed - getting the indexfile failed                  /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-void pkgAcqIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf) /*{{{*/
+// pkgAcqIndex::Failed - getting the indexfile failed                  /*{{{*/
+void pkgAcqIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)

 {
    size_t const nextExt = CompressionExtensions.find(' ');
    if (nextExt != std::string::npos)
 {
    size_t const nextExt = CompressionExtensions.find(' ');
    if (nextExt != std::string::npos)


@@ -1125,9 +1264,7 @@ void pkgAcqIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)    /*{{{*/
    TransactionManager->AbortTransaction();
 }
                                                                        /*}}}*/
    TransactionManager->AbortTransaction();
 }
                                                                        /*}}}*/

-// pkgAcqIndex::GetFinalFilename - Return the full final file path      /*{{{*/
-// ---------------------------------------------------------------------
-/* */
+// pkgAcqIndex::GetFinalFilename - Return the full final file path     /*{{{*/

 std::string pkgAcqIndex::GetFinalFilename() const
 {
    std::string FinalFile = _config->FindDir("Dir::State::lists");
 std::string pkgAcqIndex::GetFinalFilename() const
 {
    std::string FinalFile = _config->FindDir("Dir::State::lists");


@@ -1136,16 +1273,13 @@ std::string pkgAcqIndex::GetFinalFilename() const
       FinalFile += '.' + CurrentCompressionExtension;
    return FinalFile;
 }
       FinalFile += '.' + CurrentCompressionExtension;
    return FinalFile;
 }

-                                                                       /*}}}*/
-// AcqIndex::ReverifyAfterIMS - Reverify index after an ims-hit        /*{{{*/
-// ---------------------------------------------------------------------
-/* */
+                                                                       /*}}}*/
+// AcqIndex::ReverifyAfterIMS - Reverify index after an ims-hit                /*{{{*/

 void pkgAcqIndex::ReverifyAfterIMS()
 {
    // update destfile to *not* include the compression extension when doing
    // a reverify (as its uncompressed on disk already)
 void pkgAcqIndex::ReverifyAfterIMS()
 {
    // update destfile to *not* include the compression extension when doing
    // a reverify (as its uncompressed on disk already)

-   DestFile =  _config->FindDir("Dir::State::lists") + "partial/";
-   DestFile += URItoFileName(RealURI);
+   DestFile = GetPartialFileNameFromURI(RealURI);

 
    // adjust DestFile if its compressed on disk
    if (_config->FindB("Acquire::GzipIndexes",false) == true)
 
    // adjust DestFile if its compressed on disk
    if (_config->FindB("Acquire::GzipIndexes",false) == true)


@@ -1157,10 +1291,8 @@ void pkgAcqIndex::ReverifyAfterIMS()
    Desc.URI = "copy:" + FinalFile;
    QueueURI(Desc);
 }
    Desc.URI = "copy:" + FinalFile;
    QueueURI(Desc);
 }

-                                                                       /*}}}*/
-
-// AcqIndex::ValidateFile - Validate the content of the downloaded file  /*{{{*/
-// --------------------------------------------------------------------------
+                                                                       /*}}}*/
+// AcqIndex::ValidateFile - Validate the content of the downloaded file        /*{{{*/

 bool pkgAcqIndex::ValidateFile(const std::string &FileName)
 {
    // FIXME: this can go away once we only ever download stuff that
 bool pkgAcqIndex::ValidateFile(const std::string &FileName)
 {
    // FIXME: this can go away once we only ever download stuff that


@@ -1186,7 +1318,7 @@ bool pkgAcqIndex::ValidateFile(const std::string &FileName)
    }
    return true;
 }
    }
    return true;
 }

-                                                                        /*}}}*/
+                                                                       /*}}}*/

 // AcqIndex::Done - Finished a fetch                                   /*{{{*/
 // ---------------------------------------------------------------------
 /* This goes through a number of states.. On the initial fetch the
 // AcqIndex::Done - Finished a fetch                                   /*{{{*/
 // ---------------------------------------------------------------------
 /* This goes through a number of states.. On the initial fetch the


@@ -1211,8 +1343,8 @@ void pkgAcqIndex::Done(string Message,
          break;
    }
 }
          break;
    }
 }

-
-// AcqIndex::StageDownloadDone - Queue for decompress and verify        /*{{{*/
+                                                                       /*}}}*/
+// AcqIndex::StageDownloadDone - Queue for decompress and verify       /*{{{*/

 void pkgAcqIndex::StageDownloadDone(string Message,
                                     HashStringList const &Hashes,
                                     pkgAcquire::MethodConfig *Cfg)
 void pkgAcqIndex::StageDownloadDone(string Message,
                                     HashStringList const &Hashes,
                                     pkgAcquire::MethodConfig *Cfg)


@@ -1227,7 +1359,7 @@ void pkgAcqIndex::StageDownloadDone(string Message,
    }
 
    Complete = true;
    }
 
    Complete = true;

-   
+

    // Handle the unzipd case
    string FileName = LookupTag(Message,"Alt-Filename");
    if (FileName.empty() == false)
    // Handle the unzipd case
    string FileName = LookupTag(Message,"Alt-Filename");
    if (FileName.empty() == false)


@@ -1237,15 +1369,7 @@ void pkgAcqIndex::StageDownloadDone(string Message,
       DestFile += ".decomp";
       Desc.URI = "copy:" + FileName;
       QueueURI(Desc);
       DestFile += ".decomp";
       Desc.URI = "copy:" + FileName;
       QueueURI(Desc);

-      ActiveSubprocess = "copy";
-#if __GNUC__ >= 4
-       #pragma GCC diagnostic push
-       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-      Mode = "copy";
-#if __GNUC__ >= 4
-       #pragma GCC diagnostic pop
-#endif
+      SetActiveSubprocess("copy");

       return;
    }
 
       return;
    }
 


@@ -1281,13 +1405,12 @@ void pkgAcqIndex::StageDownloadDone(string Message,
    // If we have compressed indexes enabled, queue for hash verification
    if (_config->FindB("Acquire::GzipIndexes",false))
    {
    // If we have compressed indexes enabled, queue for hash verification
    if (_config->FindB("Acquire::GzipIndexes",false))
    {

-      DestFile = _config->FindDir("Dir::State::lists") + "partial/";
-      DestFile += URItoFileName(RealURI) + '.' + CurrentCompressionExtension;
+      DestFile = GetPartialFileNameFromURI(RealURI + '.' + CurrentCompressionExtension);

       EraseFileName = "";
       Stage = STAGE_DECOMPRESS_AND_VERIFY;
       Desc.URI = "copy:" + FileName;
       QueueURI(Desc);
       EraseFileName = "";
       Stage = STAGE_DECOMPRESS_AND_VERIFY;
       Desc.URI = "copy:" + FileName;
       QueueURI(Desc);

-
+      SetActiveSubprocess("copy");

       return;
     }
 
       return;
     }
 


@@ -1308,19 +1431,10 @@ void pkgAcqIndex::StageDownloadDone(string Message,
    DestFile += ".decomp";
    Desc.URI = decompProg + ":" + FileName;
    QueueURI(Desc);
    DestFile += ".decomp";
    Desc.URI = decompProg + ":" + FileName;
    QueueURI(Desc);

-
-   ActiveSubprocess = decompProg;
-#if __GNUC__ >= 4
-       #pragma GCC diagnostic push
-       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-      Mode = ActiveSubprocess.c_str();
-#if __GNUC__ >= 4
-       #pragma GCC diagnostic pop
-#endif
+   SetActiveSubprocess(decompProg);

 }
 }

-                                                                        /*}}}*/
-// pkgAcqIndex::StageDecompressDone - Final verification               /*{{{*/
+                                                                       /*}}}*/
+// pkgAcqIndex::StageDecompressDone - Final verification               /*{{{*/

 void pkgAcqIndex::StageDecompressDone(string Message,
                                       HashStringList const &Hashes,
                                       pkgAcquire::MethodConfig *Cfg)
 void pkgAcqIndex::StageDecompressDone(string Message,
                                       HashStringList const &Hashes,
                                       pkgAcquire::MethodConfig *Cfg)


@@ -1340,30 +1454,28 @@ void pkgAcqIndex::StageDecompressDone(string Message,
       Failed(Message, Cfg);
       return;
    }
       Failed(Message, Cfg);
       return;
    }

-   
+

    // remove the compressed version of the file
    unlink(EraseFileName.c_str());
    // remove the compressed version of the file
    unlink(EraseFileName.c_str());

-   
+

    // Done, queue for rename on transaction finished
    TransactionManager->TransactionStageCopy(this, DestFile, GetFinalFilename());
    // Done, queue for rename on transaction finished
    TransactionManager->TransactionStageCopy(this, DestFile, GetFinalFilename());

-   
+

    return;
 }
    return;
 }

-                                                                        /*}}}*/

                                                                        /*}}}*/
 // AcqIndexTrans::pkgAcqIndexTrans - Constructor                       /*{{{*/
 // ---------------------------------------------------------------------
 /* The Translation file is added to the queue */
 pkgAcqIndexTrans::pkgAcqIndexTrans(pkgAcquire *Owner,
                                                                        /*}}}*/
 // AcqIndexTrans::pkgAcqIndexTrans - Constructor                       /*{{{*/
 // ---------------------------------------------------------------------
 /* The Translation file is added to the queue */
 pkgAcqIndexTrans::pkgAcqIndexTrans(pkgAcquire *Owner,

-                           string URI,string URIDesc,string ShortDesc) 
+                           string URI,string URIDesc,string ShortDesc)

   : pkgAcqIndex(Owner, URI, URIDesc, ShortDesc, HashStringList())
 {
 }
   : pkgAcqIndex(Owner, URI, URIDesc, ShortDesc, HashStringList())
 {
 }

-                                                                       /*}}}*/
-pkgAcqIndexTrans::pkgAcqIndexTrans(pkgAcquire *Owner, 
-                                   pkgAcqMetaBase *TransactionManager, 
+pkgAcqIndexTrans::pkgAcqIndexTrans(pkgAcquire *Owner,
+                                   pkgAcqMetaBase *TransactionManager,

                                    IndexTarget const * const Target,
                                    IndexTarget const * const Target,

-                                   HashStringList const &ExpectedHashes, 
+                                   HashStringList const &ExpectedHashes,

                                    indexRecords *MetaIndexParser)
    : pkgAcqIndex(Owner, TransactionManager, Target, ExpectedHashes, MetaIndexParser)
 {
                                    indexRecords *MetaIndexParser)
    : pkgAcqIndex(Owner, TransactionManager, Target, ExpectedHashes, MetaIndexParser)
 {


@@ -1374,7 +1486,6 @@ pkgAcqIndexTrans::pkgAcqIndexTrans(pkgAcquire *Owner,
 }
                                                                        /*}}}*/
 // AcqIndexTrans::Custom600Headers - Insert custom request headers     /*{{{*/
 }
                                                                        /*}}}*/
 // AcqIndexTrans::Custom600Headers - Insert custom request headers     /*{{{*/

-// ---------------------------------------------------------------------

 string pkgAcqIndexTrans::Custom600Headers() const
 {
    string Final = GetFinalFilename();
 string pkgAcqIndexTrans::Custom600Headers() const
 {
    string Final = GetFinalFilename();


@@ -1386,8 +1497,6 @@ string pkgAcqIndexTrans::Custom600Headers() const
 }
                                                                        /*}}}*/
 // AcqIndexTrans::Failed - Silence failure messages for missing files  /*{{{*/
 }
                                                                        /*}}}*/
 // AcqIndexTrans::Failed - Silence failure messages for missing files  /*{{{*/

-// ---------------------------------------------------------------------
-/* */

 void pkgAcqIndexTrans::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 {
    size_t const nextExt = CompressionExtensions.find(' ');
 void pkgAcqIndexTrans::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 {
    size_t const nextExt = CompressionExtensions.find(' ');


@@ -1399,26 +1508,24 @@ void pkgAcqIndexTrans::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
       return;
    }
 
       return;
    }
 

+   Item::Failed(Message,Cnf);
+

    // FIXME: this is used often (e.g. in pkgAcqIndexTrans) so refactor
    // FIXME: this is used often (e.g. in pkgAcqIndexTrans) so refactor

-   if (Cnf->LocalOnly == true || 
+   if (Cnf->LocalOnly == true ||

        StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
        StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)

-   {      
+   {

       // Ignore this
       Status = StatDone;
       // Ignore this
       Status = StatDone;

-      Complete = false;
-      Dequeue();
-      return;

    }
    }

-
-   Item::Failed(Message,Cnf);

 }
                                                                        /*}}}*/
 }
                                                                        /*}}}*/

-
+// AcqMetaBase::Add - Add a item to the current Transaction            /*{{{*/

 void pkgAcqMetaBase::Add(Item *I)
 {
    Transaction.push_back(I);
 }
 void pkgAcqMetaBase::Add(Item *I)
 {
    Transaction.push_back(I);
 }

-
+                                                                       /*}}}*/
+// AcqMetaBase::AbortTransaction - Abort the current Transaction       /*{{{*/

 void pkgAcqMetaBase::AbortTransaction()
 {
    if(_config->FindB("Debug::Acquire::Transaction", false) == true)
 void pkgAcqMetaBase::AbortTransaction()
 {
    if(_config->FindB("Debug::Acquire::Transaction", false) == true)


@@ -1435,14 +1542,13 @@ void pkgAcqMetaBase::AbortTransaction()
          (*I)->Status = pkgAcquire::Item::StatDone;
 
       // kill files in partial
          (*I)->Status = pkgAcquire::Item::StatDone;
 
       // kill files in partial

-      string PartialFile = _config->FindDir("Dir::State::lists");
-      PartialFile += "partial/";
-      PartialFile += flNotDir((*I)->DestFile);
+      std::string const PartialFile = GetPartialFileName(flNotDir((*I)->DestFile));

       if(FileExists(PartialFile))
          Rename(PartialFile, PartialFile + ".FAILED");
    }
 }
                                                                        /*}}}*/
       if(FileExists(PartialFile))
          Rename(PartialFile, PartialFile + ".FAILED");
    }
 }
                                                                        /*}}}*/

+// AcqMetaBase::TransactionHasError - Check for errors in Transaction  /*{{{*/

 bool pkgAcqMetaBase::TransactionHasError()
 {
    for (pkgAcquire::ItemIterator I = Transaction.begin();
 bool pkgAcqMetaBase::TransactionHasError()
 {
    for (pkgAcquire::ItemIterator I = Transaction.begin();


@@ -1453,7 +1559,8 @@ bool pkgAcqMetaBase::TransactionHasError()
 
    return false;
 }
 
    return false;
 }

-// Acquire::CommitTransaction - Commit a transaction                   /*{{{*/
+                                                                       /*}}}*/
+// AcqMetaBase::CommitTransaction - Commit a transaction               /*{{{*/

 void pkgAcqMetaBase::CommitTransaction()
 {
    if(_config->FindB("Debug::Acquire::Transaction", false) == true)
 void pkgAcqMetaBase::CommitTransaction()
 {
    if(_config->FindB("Debug::Acquire::Transaction", false) == true)


@@ -1466,19 +1573,18 @@ void pkgAcqMetaBase::CommitTransaction()
    {
       if((*I)->PartialFile != "")
       {
    {
       if((*I)->PartialFile != "")
       {

-         if(_config->FindB("Debug::Acquire::Transaction", false) == true)
-            std::clog << "mv " 
-                      << (*I)->PartialFile << " -> " 
-                      <<  (*I)->DestFile << " " 
-                      << (*I)->DescURI()
-                      << std::endl;
-         Rename((*I)->PartialFile, (*I)->DestFile);
-         chmod((*I)->DestFile.c_str(),0644);
+        if(_config->FindB("Debug::Acquire::Transaction", false) == true)
+           std::clog << "mv " << (*I)->PartialFile << " -> "<< (*I)->DestFile << " "
+              << (*I)->DescURI() << std::endl;
+
+        Rename((*I)->PartialFile, (*I)->DestFile);
+        ChangeOwnerAndPermissionOfFile("CommitTransaction", (*I)->DestFile.c_str(), "root", "root", 0644);
+

       } else {
          if(_config->FindB("Debug::Acquire::Transaction", false) == true)
       } else {
          if(_config->FindB("Debug::Acquire::Transaction", false) == true)

-            std::clog << "rm " 
+            std::clog << "rm "

                       <<  (*I)->DestFile
                       <<  (*I)->DestFile

-                      << " " 
+                      << " "

                       << (*I)->DescURI()
                       << std::endl;
          unlink((*I)->DestFile.c_str());
                       << (*I)->DescURI()
                       << std::endl;
          unlink((*I)->DestFile.c_str());


@@ -1487,7 +1593,8 @@ void pkgAcqMetaBase::CommitTransaction()
       (*I)->TransactionManager = 0;
    }
 }
       (*I)->TransactionManager = 0;
    }
 }

-
+                                                                       /*}}}*/
+// AcqMetaBase::TransactionStageCopy - Stage a file for copying                /*{{{*/

 void pkgAcqMetaBase::TransactionStageCopy(Item *I,
                                           const std::string &From,
                                           const std::string &To)
 void pkgAcqMetaBase::TransactionStageCopy(Item *I,
                                           const std::string &From,
                                           const std::string &To)


@@ -1495,21 +1602,24 @@ void pkgAcqMetaBase::TransactionStageCopy(Item *I,
    I->PartialFile = From;
    I->DestFile = To;
 }
    I->PartialFile = From;
    I->DestFile = To;
 }

-
+                                                                       /*}}}*/
+// AcqMetaBase::TransactionStageRemoval - Sage a file for removal      /*{{{*/

 void pkgAcqMetaBase::TransactionStageRemoval(Item *I,
                                              const std::string &FinalFile)
 {
    I->PartialFile = "";
    I->DestFile = FinalFile; 
 }
 void pkgAcqMetaBase::TransactionStageRemoval(Item *I,
                                              const std::string &FinalFile)
 {
    I->PartialFile = "";
    I->DestFile = FinalFile; 
 }

-
-
-                                                                       /*{{{*/
-bool pkgAcqMetaBase::GenerateAuthWarning(const std::string &RealURI,
-                                         const std::string &Message)
+                                                                       /*}}}*/
+// AcqMetaBase::GenerateAuthWarning - Check gpg authentication error   /*{{{*/
+bool pkgAcqMetaBase::CheckStopAuthentication(const std::string &RealURI,
+                                             const std::string &Message)

 {
 {

+   // FIXME: this entire function can do now that we disallow going to
+   //        a unauthenticated state and can cleanly rollback
+

    string Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
    string Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);

-   
+

    if(FileExists(Final))
    {
       Status = StatTransientNetworkError;
    if(FileExists(Final))
    {
       Status = StatTransientNetworkError;


@@ -1533,29 +1643,28 @@ bool pkgAcqMetaBase::GenerateAuthWarning(const std::string &RealURI,
                       Desc.Description.c_str(),
                       LookupTag(Message,"Message").c_str());
    }
                       Desc.Description.c_str(),
                       LookupTag(Message,"Message").c_str());
    }

-   // gpgv method failed 
+   // gpgv method failed

    ReportMirrorFailure("GPGFailure");
    return false;
 }
                                                                        /*}}}*/
    ReportMirrorFailure("GPGFailure");
    return false;
 }
                                                                        /*}}}*/

-
-
-pkgAcqMetaSig::pkgAcqMetaSig(pkgAcquire *Owner,                        /*{{{*/
+// AcqMetaSig::AcqMetaSig - Constructor                                        /*{{{*/
+pkgAcqMetaSig::pkgAcqMetaSig(pkgAcquire *Owner,

                              pkgAcqMetaBase *TransactionManager,
                             string URI,string URIDesc,string ShortDesc,
                              string MetaIndexFile,
                             const vector<IndexTarget*>* IndexTargets,
                             indexRecords* MetaIndexParser) :
                              pkgAcqMetaBase *TransactionManager,
                             string URI,string URIDesc,string ShortDesc,
                              string MetaIndexFile,
                             const vector<IndexTarget*>* IndexTargets,
                             indexRecords* MetaIndexParser) :

-   pkgAcqMetaBase(Owner, IndexTargets, MetaIndexParser, 
+   pkgAcqMetaBase(Owner, IndexTargets, MetaIndexParser,

                   HashStringList(), TransactionManager),
    RealURI(URI), MetaIndexFile(MetaIndexFile), URIDesc(URIDesc),
    ShortDesc(ShortDesc)
 {
    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
                   HashStringList(), TransactionManager),
    RealURI(URI), MetaIndexFile(MetaIndexFile), URIDesc(URIDesc),
    ShortDesc(ShortDesc)
 {
    DestFile = _config->FindDir("Dir::State::lists") + "partial/";

-   DestFile += URItoFileName(URI);
+   DestFile += URItoFileName(RealURI);

 
 

-   // remove any partial downloaded sig-file in partial/. 
-   // it may confuse proxies and is too small to warrant a 
+   // remove any partial downloaded sig-file in partial/.
+   // it may confuse proxies and is too small to warrant a

    // partial download anyway
    unlink(DestFile.c_str());
 
    // partial download anyway
    unlink(DestFile.c_str());
 


@@ -1579,7 +1688,6 @@ pkgAcqMetaSig::~pkgAcqMetaSig()                                           /*{{{*/
                                                                        /*}}}*/
 // pkgAcqMetaSig::Custom600Headers - Insert custom request headers     /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // pkgAcqMetaSig::Custom600Headers - Insert custom request headers     /*{{{*/
 // ---------------------------------------------------------------------

-/* The only header we use is the last-modified header. */

 string pkgAcqMetaSig::Custom600Headers() const
 {
    string FinalFile = _config->FindDir("Dir::State::lists");
 string pkgAcqMetaSig::Custom600Headers() const
 {
    string FinalFile = _config->FindDir("Dir::State::lists");


@@ -1591,87 +1699,45 @@ string pkgAcqMetaSig::Custom600Headers() const
 
    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 }
 
    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 }

-
-void pkgAcqMetaSig::Done(string Message,unsigned long long Size, HashStringList const &Hashes,
+                                                                       /*}}}*/
+// pkgAcqMetaSig::Done - The signature was downloaded/verified         /*{{{*/
+// ---------------------------------------------------------------------
+/* The only header we use is the last-modified header. */
+void pkgAcqMetaSig::Done(string Message,unsigned long long Size,
+                         HashStringList const &Hashes,

                         pkgAcquire::MethodConfig *Cfg)
 {
    Item::Done(Message, Size, Hashes, Cfg);
 
                         pkgAcquire::MethodConfig *Cfg)
 {
    Item::Done(Message, Size, Hashes, Cfg);
 

-   string FileName = LookupTag(Message,"Filename");
-   if (FileName.empty() == true)
-   {
-      Status = StatError;
-      ErrorText = "Method gave a blank filename";
-      return;
-   }
-
-   if (FileName != DestFile)
-   {
-      // We have to copy it into place
-      Local = true;
-      Desc.URI = "copy:" + FileName;
-      QueueURI(Desc);
-      return;
-   }
-
-   if(StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
-      IMSHit = true;
-
-   // adjust paths if its a ims-hit
-   if(IMSHit)
-   {
-      string FinalFile = _config->FindDir("Dir::State::lists");
-      FinalFile += URItoFileName(RealURI);
-         
-      TransactionManager->TransactionStageCopy(this, FinalFile, FinalFile);
-   }
-
-   // queue for verify

    if(AuthPass == false)
    {
    if(AuthPass == false)
    {

-      AuthPass = true;
-      Desc.URI = "gpgv:" + DestFile;
-      DestFile = MetaIndexFile;
-      QueueURI(Desc);
+      if(CheckDownloadDone(Message, RealURI) == true)
+      {
+         // destfile will be modified to point to MetaIndexFile for the
+         // gpgv method, so we need to save it here
+         MetaIndexFileSignature = DestFile;
+         QueueForSignatureVerify(MetaIndexFile, MetaIndexFileSignature);
+      }

       return;
    }
       return;
    }

-
-   // queue to copy the file in place if it was not a ims hit, on ims
-   // hit the file is already at the right place
-   if(IMSHit == false)
-   {
-      PartialFile = _config->FindDir("Dir::State::lists") + "partial/";
-      PartialFile += URItoFileName(RealURI);
-      
-      std::string FinalFile = _config->FindDir("Dir::State::lists");
-      FinalFile += URItoFileName(RealURI);
-
-      TransactionManager->TransactionStageCopy(this, PartialFile, FinalFile);
-   }
-
-   // we parse the MetaIndexFile here because at this point we can
-   // trust the data
-   if(AuthPass == true)
+   else

    {
    {

-      // load indexes and queue further downloads
-      MetaIndexParser->Load(MetaIndexFile);
-      QueueIndexes(true);
+      if(CheckAuthDone(Message, RealURI) == true)
+      {
+         std::string FinalFile = _config->FindDir("Dir::State::lists");
+         FinalFile += URItoFileName(RealURI);
+         TransactionManager->TransactionStageCopy(this, MetaIndexFileSignature, FinalFile);
+      }

    }
    }

-
-   Complete = true;

 }
                                                                        /*}}}*/
 void pkgAcqMetaSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf)/*{{{*/
 {
    string Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
 
 }
                                                                        /*}}}*/
 void pkgAcqMetaSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf)/*{{{*/
 {
    string Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
 

-   // FIXME: duplicated code from pkgAcqMetaIndex
-   if (AuthPass == true)
-   {
-      bool Stop = GenerateAuthWarning(RealURI, Message);
-      if(Stop)
+   // check if we need to fail at this point 
+   if (AuthPass == true && CheckStopAuthentication(RealURI, Message))

          return;
          return;

-   }

 
    // FIXME: meh, this is not really elegant
    string InReleaseURI = RealURI.replace(RealURI.rfind("Release.gpg"), 12,
 
    // FIXME: meh, this is not really elegant
    string InReleaseURI = RealURI.replace(RealURI.rfind("Release.gpg"), 12,


@@ -1695,7 +1761,7 @@ void pkgAcqMetaSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf)/*{{{*/
       } else {
          _error->Error("%s", downgrade_msg.c_str());
          Rename(MetaIndexFile, MetaIndexFile+".FAILED");
       } else {
          _error->Error("%s", downgrade_msg.c_str());
          Rename(MetaIndexFile, MetaIndexFile+".FAILED");

-         Status = pkgAcquire::Item::StatError;
+        Item::Failed("Message: " + downgrade_msg, Cnf);

          TransactionManager->AbortTransaction();
          return;
       }
          TransactionManager->AbortTransaction();
          return;
       }


@@ -1703,8 +1769,7 @@ void pkgAcqMetaSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf)/*{{{*/
 
    // this ensures that any file in the lists/ dir is removed by the
    // transaction
 
    // this ensures that any file in the lists/ dir is removed by the
    // transaction

-   DestFile =  _config->FindDir("Dir::State::lists") + "partial/";
-   DestFile += URItoFileName(RealURI);
+   DestFile = GetPartialFileNameFromURI(RealURI);

    TransactionManager->TransactionStageRemoval(this, DestFile);
 
    // only allow going further if the users explicitely wants it
    TransactionManager->TransactionStageRemoval(this, DestFile);
 
    // only allow going further if the users explicitely wants it


@@ -1720,17 +1785,15 @@ void pkgAcqMetaSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf)/*{{{*/
       _error->Warning("Use --allow-insecure-repositories to force the update");
    }
 
       _error->Warning("Use --allow-insecure-repositories to force the update");
    }
 

+   Item::Failed(Message,Cnf);
+

    // FIXME: this is used often (e.g. in pkgAcqIndexTrans) so refactor
    // FIXME: this is used often (e.g. in pkgAcqIndexTrans) so refactor

-   if (Cnf->LocalOnly == true || 
+   if (Cnf->LocalOnly == true ||

        StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
        StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)

-   {      
+   {

       // Ignore this
       Status = StatDone;
       // Ignore this
       Status = StatDone;

-      Complete = false;
-      Dequeue();
-      return;

    }
    }

-   Item::Failed(Message,Cnf);

 }
                                                                        /*}}}*/
 pkgAcqMetaIndex::pkgAcqMetaIndex(pkgAcquire *Owner,                    /*{{{*/
 }
                                                                        /*}}}*/
 pkgAcqMetaIndex::pkgAcqMetaIndex(pkgAcquire *Owner,                    /*{{{*/


@@ -1759,11 +1822,10 @@ pkgAcqMetaIndex::pkgAcqMetaIndex(pkgAcquire *Owner,                     /*{{{*/
    Init(URIDesc, ShortDesc);
 }
                                                                        /*}}}*/
    Init(URIDesc, ShortDesc);
 }
                                                                        /*}}}*/

-// pkgAcqMetaIndex::Init - Delayed constructor                         /*{{{*/
+// pkgAcqMetaIndex::Init - Delayed constructor                         /*{{{*/

 void pkgAcqMetaIndex::Init(std::string URIDesc, std::string ShortDesc)
 {
 void pkgAcqMetaIndex::Init(std::string URIDesc, std::string ShortDesc)
 {

-   DestFile = _config->FindDir("Dir::State::lists") + "partial/";
-   DestFile += URItoFileName(RealURI);
+   DestFile = GetPartialFileNameFromURI(RealURI);

 
    // Create the item
    Desc.Description = URIDesc;
 
    // Create the item
    Desc.Description = URIDesc;


@@ -1775,9 +1837,9 @@ void pkgAcqMetaIndex::Init(std::string URIDesc, std::string ShortDesc)
    ExpectedAdditionalItems = IndexTargets->size();
    QueueURI(Desc);
 }
    ExpectedAdditionalItems = IndexTargets->size();
    QueueURI(Desc);
 }

+                                                                       /*}}}*/

 // pkgAcqMetaIndex::Custom600Headers - Insert custom request headers   /*{{{*/
 // ---------------------------------------------------------------------
 // pkgAcqMetaIndex::Custom600Headers - Insert custom request headers   /*{{{*/
 // ---------------------------------------------------------------------

-/* The only header we use is the last-modified header. */

 string pkgAcqMetaIndex::Custom600Headers() const
 {
    string Final = _config->FindDir("Dir::State::lists");
 string pkgAcqMetaIndex::Custom600Headers() const
 {
    string Final = _config->FindDir("Dir::State::lists");


@@ -1790,65 +1852,78 @@ string pkgAcqMetaIndex::Custom600Headers() const
    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 }
                                                                        /*}}}*/
    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 }
                                                                        /*}}}*/

-void pkgAcqMetaIndex::Done(string Message,unsigned long long Size,HashStringList const &Hashes,        /*{{{*/
+void pkgAcqMetaIndex::Done(string Message,unsigned long long Size,     /*{{{*/
+                           HashStringList const &Hashes,

                           pkgAcquire::MethodConfig *Cfg)
 {
    Item::Done(Message,Size,Hashes,Cfg);
 
                           pkgAcquire::MethodConfig *Cfg)
 {
    Item::Done(Message,Size,Hashes,Cfg);
 

-   // MetaIndexes are done in two passes: one to download the
-   // metaindex with an appropriate method, and a second to verify it
-   // with the gpgv method
-
-   if (AuthPass == true)
+   if(CheckDownloadDone(Message, RealURI))

    {
    {

-      AuthDone(Message);
+      // we have a Release file, now download the Signature, all further
+      // verify/queue for additional downloads will be done in the
+      // pkgAcqMetaSig::Done() code
+      std::string MetaIndexFile = DestFile;
+      new pkgAcqMetaSig(Owner, TransactionManager, 
+                        MetaIndexSigURI, MetaIndexSigURIDesc,
+                        MetaIndexSigShortDesc, MetaIndexFile, IndexTargets, 
+                        MetaIndexParser);

 
 

-      // all cool, move Release file into place
-      Complete = true;
+      string FinalFile = _config->FindDir("Dir::State::lists");
+      FinalFile += URItoFileName(RealURI);
+      TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);

    }
    }

-   else
-   {
-      RetrievalDone(Message);
-      if (!Complete)
-         // Still more retrieving to do
-         return;
+}
+                                                                       /*}}}*/
+bool pkgAcqMetaBase::CheckAuthDone(string Message, const string &RealURI)      /*{{{*/
+{
+   // At this point, the gpgv method has succeeded, so there is a
+   // valid signature from a key in the trusted keyring.  We
+   // perform additional verification of its contents, and use them
+   // to verify the indexes we are about to download

 
 

-      if (SigFile != "")
-      {
-         // There was a signature file, so pass it to gpgv for
-         // verification
-         if (_config->FindB("Debug::pkgAcquire::Auth", false))
-            std::cerr << "Metaindex acquired, queueing gpg verification ("
-                      << SigFile << "," << DestFile << ")\n";
-         AuthPass = true;
-         Desc.URI = "gpgv:" + SigFile;
-         QueueURI(Desc);
-        ActiveSubprocess = "gpgv";
-#if __GNUC__ >= 4
-       #pragma GCC diagnostic push
-       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-        Mode = "gpgv";
-#if __GNUC__ >= 4
-       #pragma GCC diagnostic pop
-#endif
-        return;
-      }
+   if (!MetaIndexParser->Load(DestFile))
+   {
+      Status = StatAuthError;
+      ErrorText = MetaIndexParser->ErrorText;
+      return false;

    }
 
    }
 

-   if (Complete == true)
+   if (!VerifyVendor(Message, RealURI))

    {
    {

-      string FinalFile = _config->FindDir("Dir::State::lists");
-      FinalFile += URItoFileName(RealURI);
-      if (SigFile == DestFile)
-        SigFile = FinalFile;
-
-      // queue for copy in place
-      TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);
+      return false;

    }
    }

+
+   if (_config->FindB("Debug::pkgAcquire::Auth", false))
+      std::cerr << "Signature verification succeeded: "
+                << DestFile << std::endl;
+
+   // Download further indexes with verification 
+   //
+   // it would be really nice if we could simply do
+   //    if (IMSHit == false) QueueIndexes(true)
+   // and skip the download if the Release file has not changed
+   // - but right now the list cleaner will needs to be tricked
+   //   to not delete all our packages/source indexes in this case
+   QueueIndexes(true);
+
+   return true;

 }
                                                                        /*}}}*/
 }
                                                                        /*}}}*/

-void pkgAcqMetaIndex::RetrievalDone(string Message)                    /*{{{*/
+// pkgAcqMetaBase::QueueForSignatureVerify                             /*{{{*/
+void pkgAcqMetaBase::QueueForSignatureVerify(const std::string &MetaIndexFile,
+                                    const std::string &MetaIndexFileSignature)
+{
+   AuthPass = true;
+   Desc.URI = "gpgv:" + MetaIndexFileSignature;
+   DestFile = MetaIndexFile;
+   QueueURI(Desc);
+   SetActiveSubprocess("gpgv");
+}
+                                                                       /*}}}*/
+// pkgAcqMetaBase::CheckDownloadDone                                   /*{{{*/
+bool pkgAcqMetaBase::CheckDownloadDone(const std::string &Message,
+                                       const std::string &RealURI)

 {
    // We have just finished downloading a Release file (it is not
    // verified yet)
 {
    // We have just finished downloading a Release file (it is not
    // verified yet)


@@ -1858,7 +1933,7 @@ void pkgAcqMetaIndex::RetrievalDone(string Message)                       /*{{{*/
    {
       Status = StatError;
       ErrorText = "Method gave a blank filename";
    {
       Status = StatError;
       ErrorText = "Method gave a blank filename";

-      return;
+      return false;

    }
 
    if (FileName != DestFile)
    }
 
    if (FileName != DestFile)


@@ -1866,7 +1941,7 @@ void pkgAcqMetaIndex::RetrievalDone(string Message)                       /*{{{*/
       Local = true;
       Desc.URI = "copy:" + FileName;
       QueueURI(Desc);
       Local = true;
       Desc.URI = "copy:" + FileName;
       QueueURI(Desc);

-      return;
+      return false;

    }
 
    // make sure to verify against the right file on I-M-S hit
    }
 
    // make sure to verify against the right file on I-M-S hit


@@ -1875,101 +1950,13 @@ void pkgAcqMetaIndex::RetrievalDone(string Message)                    /*{{{*/
    {
       string FinalFile = _config->FindDir("Dir::State::lists");
       FinalFile += URItoFileName(RealURI);
    {
       string FinalFile = _config->FindDir("Dir::State::lists");
       FinalFile += URItoFileName(RealURI);

-      if (SigFile == DestFile)
-      {
-        SigFile = FinalFile;
-#if 0
-        // constructor of pkgAcqMetaClearSig moved it out of the way,
-        // now move it back in on IMS hit for the 'old' file
-        string const OldClearSig = DestFile + ".reverify";
-        if (RealFileExists(OldClearSig) == true)
-           Rename(OldClearSig, FinalFile);
-#endif
-      }

       DestFile = FinalFile;
    }
 
       DestFile = FinalFile;
    }
 

-   // queue a signature
-   if(SigFile != DestFile)
-      new pkgAcqMetaSig(Owner, TransactionManager, 
-                        MetaIndexSigURI, MetaIndexSigURIDesc,
-                        MetaIndexSigShortDesc, DestFile, IndexTargets, 
-                        MetaIndexParser);
-
+   // set Item to complete as the remaining work is all local (verify etc)

    Complete = true;
    Complete = true;

-}
-                                                                       /*}}}*/
-void pkgAcqMetaIndex::AuthDone(string Message)                         /*{{{*/
-{
-   // At this point, the gpgv method has succeeded, so there is a
-   // valid signature from a key in the trusted keyring.  We
-   // perform additional verification of its contents, and use them
-   // to verify the indexes we are about to download
-
-   if (!MetaIndexParser->Load(DestFile))
-   {
-      Status = StatAuthError;
-      ErrorText = MetaIndexParser->ErrorText;
-      return;
-   }
-
-   if (!VerifyVendor(Message))
-   {
-      return;
-   }
-
-   if (_config->FindB("Debug::pkgAcquire::Auth", false))
-      std::cerr << "Signature verification succeeded: "
-                << DestFile << std::endl;
-
-// we ensure this by other means
-#if 0 
-   // do not trust any previously unverified content that we may have
-   string LastGoodSigFile = _config->FindDir("Dir::State::lists").append("partial/").append(URItoFileName(RealURI));
-   if (DestFile != SigFile)
-      LastGoodSigFile.append(".gpg");
-   LastGoodSigFile.append(".reverify");
-   if(IMSHit == false && RealFileExists(LastGoodSigFile) == false)
-   {
-      for (vector <struct IndexTarget*>::const_iterator Target = IndexTargets->begin();
-           Target != IndexTargets->end();
-           ++Target)
-      {
-         // remove old indexes
-         std::string index = _config->FindDir("Dir::State::lists") +
-            URItoFileName((*Target)->URI);
-         unlink(index.c_str());
-         // and also old gzipindexes
-         std::vector<std::string> types = APT::Configuration::getCompressionTypes();
-         for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
-         {
-            index += '.' + (*t);
-            unlink(index.c_str());
-         }
-      }
-   }
-#endif
-
-   // Download further indexes with verification 
-   //
-   // it would be really nice if we could simply do
-   //    if (IMSHit == false) QueueIndexes(true)
-   // and skip the download if the Release file has not changed
-   // - but right now the list cleaner will needs to be tricked
-   //   to not delete all our packages/source indexes in this case
-   QueueIndexes(true);
-
-#if 0
-   // is it a clearsigned MetaIndex file?
-   if (DestFile == SigFile)
-      return;

 
 

-   // Done, move signature file into position
-   string VerifiedSigFile = _config->FindDir("Dir::State::lists") +
-      URItoFileName(RealURI) + ".gpg";
-   Rename(SigFile,VerifiedSigFile);
-   chmod(VerifiedSigFile.c_str(),0644);
-#endif
+   return true;

 }
                                                                        /*}}}*/
 void pkgAcqMetaBase::QueueIndexes(bool verify)                         /*{{{*/
 }
                                                                        /*}}}*/
 void pkgAcqMetaBase::QueueIndexes(bool verify)                         /*{{{*/


@@ -2058,7 +2045,7 @@ void pkgAcqMetaBase::QueueIndexes(bool verify)                            /*{{{*/
    }
 }
                                                                        /*}}}*/
    }
 }
                                                                        /*}}}*/

-bool pkgAcqMetaIndex::VerifyVendor(string Message)                     /*{{{*/
+bool pkgAcqMetaBase::VerifyVendor(string Message, const string &RealURI)/*{{{*/

 {
    string::size_type pos;
 
 {
    string::size_type pos;
 


@@ -2135,59 +2122,40 @@ bool pkgAcqMetaIndex::VerifyVendor(string Message)                      /*{{{*/
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

-// pkgAcqMetaIndex::Failed - no Release file present or no signature file present      /*{{{*/
-// ---------------------------------------------------------------------
-/* */
+// pkgAcqMetaIndex::Failed - no Release file present                   /*{{{*/

 void pkgAcqMetaIndex::Failed(string Message,
 void pkgAcqMetaIndex::Failed(string Message,

-                             pkgAcquire::MethodConfig * /*Cnf*/)
+                             pkgAcquire::MethodConfig * Cnf)

 {
 {

-   string Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
-
-   if (AuthPass == true)
-   {
-      bool Stop = GenerateAuthWarning(RealURI, Message);
-      if(Stop)
-         return;
-   }
-
-   /* Always move the meta index, even if gpgv failed. This ensures
-    * that PackageFile objects are correctly filled in */
-   if (FileExists(DestFile)) 
-   {
-      string FinalFile = _config->FindDir("Dir::State::lists");
-      FinalFile += URItoFileName(RealURI);
-      /* InRelease files become Release files, otherwise
-       * they would be considered as trusted later on */
-      if (SigFile == DestFile) {
-        RealURI = RealURI.replace(RealURI.rfind("InRelease"), 9,
-                                      "Release");
-        FinalFile = FinalFile.replace(FinalFile.rfind("InRelease"), 9,
-                                      "Release");
-        SigFile = FinalFile;
-      }
+   pkgAcquire::Item::Failed(Message, Cnf);
+   Status = StatDone;

 
 

-      // Done, queue for rename on transaction finished
-      TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);
-   }
+   string FinalFile = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);

 
 

-   _error->Warning(_("The data from '%s' is not signed. Packages "
-                     "from that repository can not be authenticated."),
-                   URIDesc.c_str());
+   _error->Warning(_("The repository '%s' does not have a Release file. "
+                     "This is deprecated, please contact the owner of the "
+                     "repository."), URIDesc.c_str());

 
 

-   // No Release file was present, or verification failed, so fall
+   // No Release file was present so fall

    // back to queueing Packages files without verification
    // only allow going further if the users explicitely wants it
    if(_config->FindB("Acquire::AllowInsecureRepositories") == true)
    {
    // back to queueing Packages files without verification
    // only allow going further if the users explicitely wants it
    if(_config->FindB("Acquire::AllowInsecureRepositories") == true)
    {

+      // Done, queue for rename on transaction finished
+      if (FileExists(DestFile)) 
+         TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);
+
+      // queue without any kind of hashsum support

       QueueIndexes(false);
    } else {
       // warn if the repository is unsinged
       _error->Warning("Use --allow-insecure-repositories to force the update");
       QueueIndexes(false);
    } else {
       // warn if the repository is unsinged
       _error->Warning("Use --allow-insecure-repositories to force the update");

-   } 
+      TransactionManager->AbortTransaction();
+      Status = StatError;
+      return;
+   }

 }
                                                                        /*}}}*/
 }
                                                                        /*}}}*/

-
-void pkgAcqMetaIndex::Finished()
+void pkgAcqMetaIndex::Finished()                                       /*{{{*/

 {
    if(_config->FindB("Debug::Acquire::Transaction", false) == true)
       std::clog << "Finished: " << DestFile <<std::endl;
 {
    if(_config->FindB("Debug::Acquire::Transaction", false) == true)
       std::clog << "Finished: " << DestFile <<std::endl;


@@ -2195,8 +2163,7 @@ void pkgAcqMetaIndex::Finished()
       TransactionManager->TransactionHasError() == false)
       TransactionManager->CommitTransaction();
 }
       TransactionManager->TransactionHasError() == false)
       TransactionManager->CommitTransaction();
 }

-
-
+                                                                       /*}}}*/

 pkgAcqMetaClearSig::pkgAcqMetaClearSig(pkgAcquire *Owner,              /*{{{*/
                string const &URI, string const &URIDesc, string const &ShortDesc,
                string const &MetaIndexURI, string const &MetaIndexURIDesc, string const &MetaIndexShortDesc,
 pkgAcqMetaClearSig::pkgAcqMetaClearSig(pkgAcquire *Owner,              /*{{{*/
                string const &URI, string const &URIDesc, string const &ShortDesc,
                string const &MetaIndexURI, string const &MetaIndexURIDesc, string const &MetaIndexShortDesc,


@@ -2207,39 +2174,17 @@ pkgAcqMetaClearSig::pkgAcqMetaClearSig(pkgAcquire *Owner,               /*{{{*/
        MetaIndexURI(MetaIndexURI), MetaIndexURIDesc(MetaIndexURIDesc), MetaIndexShortDesc(MetaIndexShortDesc),
        MetaSigURI(MetaSigURI), MetaSigURIDesc(MetaSigURIDesc), MetaSigShortDesc(MetaSigShortDesc)
 {
        MetaIndexURI(MetaIndexURI), MetaIndexURIDesc(MetaIndexURIDesc), MetaIndexShortDesc(MetaIndexShortDesc),
        MetaSigURI(MetaSigURI), MetaSigURIDesc(MetaSigURIDesc), MetaSigShortDesc(MetaSigShortDesc)
 {

-   SigFile = DestFile;
-

    // index targets + (worst case:) Release/Release.gpg
    ExpectedAdditionalItems = IndexTargets->size() + 2;
 
    // index targets + (worst case:) Release/Release.gpg
    ExpectedAdditionalItems = IndexTargets->size() + 2;
 

-#if 0
-   // keep the old InRelease around in case of transistent network errors
-   string const Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
-   if (RealFileExists(Final) == true)
-   {
-      string const LastGoodSig = DestFile + ".reverify";
-      Rename(Final,LastGoodSig);
-   }
-#endif

 }
                                                                        /*}}}*/
 pkgAcqMetaClearSig::~pkgAcqMetaClearSig()                              /*{{{*/
 {
 }
                                                                        /*}}}*/
 pkgAcqMetaClearSig::~pkgAcqMetaClearSig()                              /*{{{*/
 {

-#if 0
-   // if the file was never queued undo file-changes done in the constructor
-   if (QueueCounter == 1 && Status == StatIdle && FileSize == 0 && Complete == false)
-   {
-      string const Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
-      string const LastGoodSig = DestFile + ".reverify";
-      if (RealFileExists(Final) == false && RealFileExists(LastGoodSig) == true)
-        Rename(LastGoodSig, Final);
-   }
-#endif

 }
                                                                        /*}}}*/
 // pkgAcqMetaClearSig::Custom600Headers - Insert custom request headers        /*{{{*/
 // ---------------------------------------------------------------------
 }
                                                                        /*}}}*/
 // pkgAcqMetaClearSig::Custom600Headers - Insert custom request headers        /*{{{*/
 // ---------------------------------------------------------------------

-// FIXME: this can go away once the InRelease file is used widely

 string pkgAcqMetaClearSig::Custom600Headers() const
 {
    string Final = _config->FindDir("Dir::State::lists");
 string pkgAcqMetaClearSig::Custom600Headers() const
 {
    string Final = _config->FindDir("Dir::State::lists");


@@ -2257,8 +2202,8 @@ string pkgAcqMetaClearSig::Custom600Headers() const
                                                                        /*}}}*/
 // pkgAcqMetaClearSig::Done - We got a file                            /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // pkgAcqMetaClearSig::Done - We got a file                            /*{{{*/
 // ---------------------------------------------------------------------

-void pkgAcqMetaClearSig::Done(std::string Message,unsigned long long Size, 
-                              HashStringList const &Hashes,
+void pkgAcqMetaClearSig::Done(std::string Message,unsigned long long /*Size*/,
+                              HashStringList const &/*Hashes*/,

                               pkgAcquire::MethodConfig *Cnf)
 {
    // if we expect a ClearTextSignature (InRelase), ensure that
                               pkgAcquire::MethodConfig *Cnf)
 {
    // if we expect a ClearTextSignature (InRelase), ensure that


@@ -2271,11 +2216,30 @@ void pkgAcqMetaClearSig::Done(std::string Message,unsigned long long Size,
       TransactionManager->AbortTransaction();
       return;
    }
       TransactionManager->AbortTransaction();
       return;
    }

-   pkgAcqMetaIndex::Done(Message, Size, Hashes, Cnf);
+
+   if(AuthPass == false)
+   {
+      if(CheckDownloadDone(Message, RealURI) == true)
+         QueueForSignatureVerify(DestFile, DestFile);
+      return;
+   }
+   else
+   {
+      if(CheckAuthDone(Message, RealURI) == true)
+      {
+         string FinalFile = _config->FindDir("Dir::State::lists");
+         FinalFile += URItoFileName(RealURI);
+
+         // queue for copy in place
+         TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);
+      }
+   }

 }
                                                                        /*}}}*/
 void pkgAcqMetaClearSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf) /*{{{*/
 {
 }
                                                                        /*}}}*/
 void pkgAcqMetaClearSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf) /*{{{*/
 {

+   Item::Failed(Message, Cnf);
+

    // we failed, we will not get additional items from this method
    ExpectedAdditionalItems = 0;
 
    // we failed, we will not get additional items from this method
    ExpectedAdditionalItems = 0;
 


@@ -2287,17 +2251,53 @@ void pkgAcqMetaClearSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf) /*
       string FinalFile = _config->FindDir("Dir::State::lists");
       FinalFile.append(URItoFileName(RealURI));
       TransactionManager->TransactionStageRemoval(this, FinalFile);
       string FinalFile = _config->FindDir("Dir::State::lists");
       FinalFile.append(URItoFileName(RealURI));
       TransactionManager->TransactionStageRemoval(this, FinalFile);

+      Status = StatDone;

 
       new pkgAcqMetaIndex(Owner, TransactionManager,
                        MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,
                        MetaSigURI, MetaSigURIDesc, MetaSigShortDesc,
                        IndexTargets, MetaIndexParser);
 
       new pkgAcqMetaIndex(Owner, TransactionManager,
                        MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,
                        MetaSigURI, MetaSigURIDesc, MetaSigShortDesc,
                        IndexTargets, MetaIndexParser);

-      if (Cnf->LocalOnly == true ||
-         StringToBool(LookupTag(Message, "Transient-Failure"), false) == false)
-        Dequeue();

    }
    else
    }
    else

-      pkgAcqMetaIndex::Failed(Message, Cnf);
+   {
+      if(CheckStopAuthentication(RealURI, Message))
+         return;
+
+      _error->Warning(_("The data from '%s' is not signed. Packages "
+                        "from that repository can not be authenticated."),
+                      URIDesc.c_str());
+
+      // No Release file was present, or verification failed, so fall
+      // back to queueing Packages files without verification
+      // only allow going further if the users explicitely wants it
+      if(_config->FindB("Acquire::AllowInsecureRepositories") == true)
+      {
+        Status = StatDone;
+
+         /* Always move the meta index, even if gpgv failed. This ensures
+          * that PackageFile objects are correctly filled in */
+         if (FileExists(DestFile))
+         {
+            string FinalFile = _config->FindDir("Dir::State::lists");
+            FinalFile += URItoFileName(RealURI);
+            /* InRelease files become Release files, otherwise
+             * they would be considered as trusted later on */
+            RealURI = RealURI.replace(RealURI.rfind("InRelease"), 9,
+                                      "Release");
+            FinalFile = FinalFile.replace(FinalFile.rfind("InRelease"), 9,
+                                          "Release");
+
+            // Done, queue for rename on transaction finished
+            TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);
+         }
+         QueueIndexes(false);
+      } else {
+         // warn if the repository is unsigned
+         _error->Warning("Use --allow-insecure-repositories to force the update");
+         TransactionManager->AbortTransaction();
+         Status = StatError;
+      }
+   }

 }
                                                                        /*}}}*/
 // AcqArchive::AcqArchive - Constructor                                        /*{{{*/
 }
                                                                        /*}}}*/
 // AcqArchive::AcqArchive - Constructor                                        /*{{{*/


@@ -2475,7 +2475,10 @@ bool pkgAcqArchive::QueueNext()
         if ((unsigned long long)Buf.st_size > Version->Size)
            unlink(DestFile.c_str());
         else
         if ((unsigned long long)Buf.st_size > Version->Size)
            unlink(DestFile.c_str());
         else

+        {

            PartialSize = Buf.st_size;
            PartialSize = Buf.st_size;

+           ChangeOwnerAndPermissionOfFile("pkgAcqArchive::QueueNext", FinalFile.c_str(), "_apt", "root", 0600);
+        }

       }
 
       // Disables download of archives - useful if no real installation follows,
       }
 
       // Disables download of archives - useful if no real installation follows,


@@ -2531,21 +2534,20 @@ void pkgAcqArchive::Done(string Message,unsigned long long Size, HashStringList
       return;
    }
 
       return;
    }
 

-   Complete = true;
-

    // Reference filename
    if (FileName != DestFile)
    {
       StoreFilename = DestFile = FileName;
       Local = true;
    // Reference filename
    if (FileName != DestFile)
    {
       StoreFilename = DestFile = FileName;
       Local = true;

+      Complete = true;

       return;
    }
       return;
    }

-   
+

    // Done, move it into position
    string FinalFile = _config->FindDir("Dir::Cache::Archives");
    FinalFile += flNotDir(StoreFilename);
    Rename(DestFile,FinalFile);
    // Done, move it into position
    string FinalFile = _config->FindDir("Dir::Cache::Archives");
    FinalFile += flNotDir(StoreFilename);
    Rename(DestFile,FinalFile);

-   
+   ChangeOwnerAndPermissionOfFile("pkgAcqArchive::Done", FinalFile.c_str(), "root", "root", 0644);

    StoreFilename = DestFile = FinalFile;
    Complete = true;
 }
    StoreFilename = DestFile = FinalFile;
    Complete = true;
 }


@@ -2641,7 +2643,10 @@ pkgAcqFile::pkgAcqFile(pkgAcquire *Owner,string URI, HashStringList const &Hashe
       if ((Size > 0) && (unsigned long long)Buf.st_size > Size)
         unlink(DestFile.c_str());
       else
       if ((Size > 0) && (unsigned long long)Buf.st_size > Size)
         unlink(DestFile.c_str());
       else

+      {

         PartialSize = Buf.st_size;
         PartialSize = Buf.st_size;

+        ChangeOwnerAndPermissionOfFile("pkgAcqFile", DestFile.c_str(), "_apt", "root", 0600);
+      }

    }
 
    QueueURI(Desc);
    }
 
    QueueURI(Desc);