Only check for valid Date if checking Valid-Until.

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

diff --git a/apt-pkg/acquire.cc b/apt-pkg/acquire.cc
index a74f1c2f648697cef952f91a70a580313d827d06..4ccfa26052a5a2488a072c143674801f393d7f96 100644 (file)
--- a/apt-pkg/acquire.cc
+++ b/apt-pkg/acquire.cc
@@ -30,6 +30,7 @@
 #include <iostream>
 #include <sstream>
 #include <iomanip>
 #include <iostream>
 #include <sstream>
 #include <iomanip>

+#include <memory>

 
 #include <stdio.h>
 #include <stdlib.h>
 
 #include <stdio.h>
 #include <stdlib.h>


@@ -76,10 +77,10 @@ void pkgAcquire::Initialize()
 
    // chown the auth.conf file as it will be accessed by our methods
    std::string const SandboxUser = _config->Find("APT::Sandbox::User");
 
    // chown the auth.conf file as it will be accessed by our methods
    std::string const SandboxUser = _config->Find("APT::Sandbox::User");

-   if (getuid() == 0 && SandboxUser.empty() == false) // if we aren't root, we can't chown, so don't try it
+   if (getuid() == 0 && SandboxUser.empty() == false && SandboxUser != "root") // if we aren't root, we can't chown, so don't try it

    {
       struct passwd const * const pw = getpwnam(SandboxUser.c_str());
    {
       struct passwd const * const pw = getpwnam(SandboxUser.c_str());

-      struct group const * const gr = getgrnam("root");
+      struct group const * const gr = getgrnam(ROOT_GROUP);

       if (pw != NULL && gr != NULL)
       {
         std::string const AuthConf = _config->FindFile("Dir::Etc::netrc");
       if (pw != NULL && gr != NULL)
       {
         std::string const AuthConf = _config->FindFile("Dir::Etc::netrc");


@@ -102,10 +103,10 @@ static bool SetupAPTPartialDirectory(std::string const &grand, std::string const
       return false;
 
    std::string const SandboxUser = _config->Find("APT::Sandbox::User");
       return false;
 
    std::string const SandboxUser = _config->Find("APT::Sandbox::User");

-   if (getuid() == 0 && SandboxUser.empty() == false) // if we aren't root, we can't chown, so don't try it
+   if (getuid() == 0 && SandboxUser.empty() == false && SandboxUser != "root") // if we aren't root, we can't chown, so don't try it

    {
       struct passwd const * const pw = getpwnam(SandboxUser.c_str());
    {
       struct passwd const * const pw = getpwnam(SandboxUser.c_str());

-      struct group const * const gr = getgrnam("root");
+      struct group const * const gr = getgrnam(ROOT_GROUP);

       if (pw != NULL && gr != NULL)
       {
          // chown the partial dir
       if (pw != NULL && gr != NULL)
       {
          // chown the partial dir


@@ -268,6 +269,42 @@ void pkgAcquire::Remove(Worker *Work)
    it is constructed which creates a queue (based on the current queue
    mode) and puts the item in that queue. If the system is running then
    the queue might be started. */
    it is constructed which creates a queue (based on the current queue
    mode) and puts the item in that queue. If the system is running then
    the queue might be started. */

+static bool CheckForBadItemAndFailIt(pkgAcquire::Item * const Item,
+      pkgAcquire::MethodConfig const * const Config, pkgAcquireStatus * const Log)
+{
+   auto SavedDesc = Item->GetItemDesc();
+   if (Item->IsRedirectionLoop(SavedDesc.URI))
+   {
+      std::string const Message = "400 URI Failure"
+        "\nURI: " + SavedDesc.URI +
+        "\nFilename: " + Item->DestFile +
+        "\nFailReason: RedirectionLoop";
+
+      Item->Status = pkgAcquire::Item::StatError;
+      Item->Failed(Message, Config);
+      if (Log != nullptr)
+        Log->Fail(SavedDesc);
+      return true;
+   }
+
+   HashStringList const hsl = Item->GetExpectedHashes();
+   if (hsl.usable() == false && Item->HashesRequired() &&
+        _config->Exists("Acquire::ForceHash") == false)
+   {
+      std::string const Message = "400 URI Failure"
+        "\nURI: " + SavedDesc.URI +
+        "\nFilename: " + Item->DestFile +
+        "\nFailReason: WeakHashSums";
+
+      auto SavedDesc = Item->GetItemDesc();
+      Item->Status = pkgAcquire::Item::StatAuthError;
+      Item->Failed(Message, Config);
+      if (Log != nullptr)
+        Log->Fail(SavedDesc);
+      return true;
+   }
+   return false;
+}

 void pkgAcquire::Enqueue(ItemDesc &Item)
 {
    // Determine which queue to put the item in
 void pkgAcquire::Enqueue(ItemDesc &Item)
 {
    // Determine which queue to put the item in


@@ -276,6 +313,13 @@ void pkgAcquire::Enqueue(ItemDesc &Item)
    if (Name.empty() == true)
       return;
 
    if (Name.empty() == true)
       return;
 

+   /* the check for running avoids that we produce errors
+      in logging before we actually have started, which would
+      be easier to implement but would confuse users/implementations
+      so we check the items skipped here in #Startup */
+   if (Running && CheckForBadItemAndFailIt(Item.Owner, Config, Log))
+      return;
+

    // Find the queue structure
    Queue *I = Queues;
    for (; I != 0 && I->Name != Name; I = I->Next);
    // Find the queue structure
    Queue *I = Queues;
    for (; I != 0 && I->Name != Name; I = I->Next);


@@ -350,8 +394,60 @@ string pkgAcquire::QueueName(string Uri,MethodConfig const *&Config)
    if (Config->SingleInstance == true || QueueMode == QueueAccess)
       return U.Access;
 
    if (Config->SingleInstance == true || QueueMode == QueueAccess)
       return U.Access;
 

-   string AccessSchema = U.Access + ':',
-       FullQueueName = AccessSchema + U.Host;
+   string AccessSchema = U.Access + ':';
+   string FullQueueName;
+
+   if (U.Host.empty())
+   {
+      long existing = 0;
+      // check how many queues exist already and reuse empty ones
+      for (Queue const *I = Queues; I != 0; I = I->Next)
+        if (I->Name.compare(0, AccessSchema.length(), AccessSchema) == 0)
+        {
+           if (I->Items == nullptr)
+              return I->Name;
+           ++existing;
+        }
+
+#ifdef _SC_NPROCESSORS_ONLN
+      long cpuCount = sysconf(_SC_NPROCESSORS_ONLN) * 2;
+#else
+      long cpuCount = 10;
+#endif
+      cpuCount = _config->FindI("Acquire::QueueHost::Limit", cpuCount);
+
+      if (cpuCount <= 0 || existing < cpuCount)
+        strprintf(FullQueueName, "%s%ld", AccessSchema.c_str(), existing);
+      else
+      {
+        long const randomQueue = random() % cpuCount;
+        strprintf(FullQueueName, "%s%ld", AccessSchema.c_str(), randomQueue);
+      }
+
+      if (Debug)
+         clog << "Chose random queue " << FullQueueName << " for " << Uri << endl;
+   } else
+   {
+      FullQueueName = AccessSchema + U.Host;
+
+      int parallel(_config->FindI("Acquire::"+U.Access+"::MaxParallel",8));
+      if (parallel > 0) {
+        typedef map<string, int> indexmap;
+        static indexmap indices;
+
+        pair<indexmap::iterator, bool> cache(indices.insert(indexmap::value_type(FullQueueName, -1)));
+        if (cache.second || cache.first->second == -1) {
+           int &index(indices[U.Access]);
+           if (index >= parallel)
+              index = 0;
+           cache.first->second = index++;
+        }
+
+        ostringstream value;
+        value << U.Access << "::" << cache.first->second;
+        FullQueueName = value.str();
+      }
+   }

    unsigned int Instances = 0, SchemaLength = AccessSchema.length();
 
    Queue *I = Queues;
    unsigned int Instances = 0, SchemaLength = AccessSchema.length();
 
    Queue *I = Queues;


@@ -427,20 +523,30 @@ void pkgAcquire::SetFds(int &Fd,fd_set *RSet,fd_set *WSet)
    }
 }
                                                                        /*}}}*/
    }
 }
                                                                        /*}}}*/

-// Acquire::RunFds - Deal with active FDs                              /*{{{*/
+// Acquire::RunFds - compatibility remove on next abi/api break                /*{{{*/
+void pkgAcquire::RunFds(fd_set *RSet,fd_set *WSet)
+{
+   RunFdsSane(RSet, WSet);
+}
+                                                                       /*}}}*/
+// Acquire::RunFdsSane - Deal with active FDs                          /*{{{*/

 // ---------------------------------------------------------------------
 /* Dispatch active FDs over to the proper workers. It is very important
    that a worker never be erased while this is running! The queue class
    should never erase a worker except during shutdown processing. */
 // ---------------------------------------------------------------------
 /* Dispatch active FDs over to the proper workers. It is very important
    that a worker never be erased while this is running! The queue class
    should never erase a worker except during shutdown processing. */

-void pkgAcquire::RunFds(fd_set *RSet,fd_set *WSet)
+bool pkgAcquire::RunFdsSane(fd_set *RSet,fd_set *WSet)

 {
 {

+   bool Res = true;
+

    for (Worker *I = Workers; I != 0; I = I->NextAcquire)
    {
       if (I->InFd >= 0 && FD_ISSET(I->InFd,RSet) != 0)
    for (Worker *I = Workers; I != 0; I = I->NextAcquire)
    {
       if (I->InFd >= 0 && FD_ISSET(I->InFd,RSet) != 0)

-        I->InFdReady();
+        Res &= I->InFdReady();

       if (I->OutFd >= 0 && FD_ISSET(I->OutFd,WSet) != 0)
       if (I->OutFd >= 0 && FD_ISSET(I->OutFd,WSet) != 0)

-        I->OutFdReady();
+        Res &= I->OutFdReady();

    }
    }

+
+   return Res;

 }
                                                                        /*}}}*/
 // Acquire::Run - Run the fetch sequence                               /*{{{*/
 }
                                                                        /*}}}*/
 // Acquire::Run - Run the fetch sequence                               /*{{{*/


@@ -448,65 +554,123 @@ void pkgAcquire::RunFds(fd_set *RSet,fd_set *WSet)
 /* This runs the queues. It manages a select loop for all of the
    Worker tasks. The workers interact with the queues and items to
    manage the actual fetch. */
 /* This runs the queues. It manages a select loop for all of the
    Worker tasks. The workers interact with the queues and items to
    manage the actual fetch. */

+static bool IsAccessibleBySandboxUser(std::string const &filename, bool const ReadWrite)
+{
+   // you would think this is easily to answer with faccessat, right? Wrong!
+   // It e.g. gets groups wrong, so the only thing which works reliable is trying
+   // to open the file we want to open later on…
+   if (unlikely(filename.empty()))
+      return true;
+
+   if (ReadWrite == false)
+   {
+      errno = 0;
+      // can we read a file? Note that non-existing files are "fine"
+      int const fd = open(filename.c_str(), O_RDONLY | O_CLOEXEC);
+      if (fd == -1 && errno == EACCES)
+        return false;
+      close(fd);
+      return true;
+   }
+   else
+   {
+      // the file might not exist yet and even if it does we will fix permissions,
+      // so important is here just that the directory it is in allows that
+      std::string const dirname = flNotFile(filename);
+      if (unlikely(dirname.empty()))
+        return true;
+
+      char const * const filetag = ".apt-acquire-privs-test.XXXXXX";
+      std::string const tmpfile_tpl = flCombine(dirname, filetag);
+      std::unique_ptr<char, decltype(std::free) *> tmpfile { strdup(tmpfile_tpl.c_str()), std::free };
+      int const fd = mkstemp(tmpfile.get());
+      if (fd == -1 && errno == EACCES)
+        return false;
+      RemoveFile("IsAccessibleBySandboxUser", tmpfile.get());
+      close(fd);
+      return true;
+   }
+}

 static void CheckDropPrivsMustBeDisabled(pkgAcquire const &Fetcher)
 {
    if(getuid() != 0)
       return;
 
 static void CheckDropPrivsMustBeDisabled(pkgAcquire const &Fetcher)
 {
    if(getuid() != 0)
       return;
 

-   std::string SandboxUser = _config->Find("APT::Sandbox::User");
-   if (SandboxUser.empty())
+   std::string const SandboxUser = _config->Find("APT::Sandbox::User");
+   if (SandboxUser.empty() || SandboxUser == "root")

       return;
 
    struct passwd const * const pw = getpwnam(SandboxUser.c_str());
    if (pw == NULL)
       return;
 
    struct passwd const * const pw = getpwnam(SandboxUser.c_str());
    if (pw == NULL)

+   {
+      _error->Warning(_("No sandbox user '%s' on the system, can not drop privileges"), SandboxUser.c_str());
+      _config->Set("APT::Sandbox::User", "");

       return;
       return;

+   }

 
    gid_t const old_euid = geteuid();
    gid_t const old_egid = getegid();
 
    gid_t const old_euid = geteuid();
    gid_t const old_egid = getegid();

+
+   long const ngroups_max = sysconf(_SC_NGROUPS_MAX);
+   std::unique_ptr<gid_t[]> old_gidlist(new gid_t[ngroups_max]);
+   if (unlikely(old_gidlist == NULL))
+      return;
+   ssize_t old_gidlist_nr;
+   if ((old_gidlist_nr = getgroups(ngroups_max, old_gidlist.get())) < 0)
+   {
+      _error->FatalE("getgroups", "getgroups %lu failed", ngroups_max);
+      old_gidlist[0] = 0;
+      old_gidlist_nr = 1;
+   }
+   if (setgroups(1, &pw->pw_gid))
+      _error->FatalE("setgroups", "setgroups %u failed", pw->pw_gid);
+

    if (setegid(pw->pw_gid) != 0)
    if (setegid(pw->pw_gid) != 0)

-      _error->Errno("setegid", "setegid %u failed", pw->pw_gid);
+      _error->FatalE("setegid", "setegid %u failed", pw->pw_gid);

    if (seteuid(pw->pw_uid) != 0)
    if (seteuid(pw->pw_uid) != 0)

-      _error->Errno("seteuid", "seteuid %u failed", pw->pw_uid);
+      _error->FatalE("seteuid", "seteuid %u failed", pw->pw_uid);

 
    for (pkgAcquire::ItemCIterator I = Fetcher.ItemsBegin();
        I != Fetcher.ItemsEnd(); ++I)
    {
 
    for (pkgAcquire::ItemCIterator I = Fetcher.ItemsBegin();
        I != Fetcher.ItemsEnd(); ++I)
    {

-      std::string filename = (*I)->DestFile;
-      if (filename.empty())
-        continue;
-

       // no need to drop privileges for a complete file
       // no need to drop privileges for a complete file

-      if ((*I)->Complete == true)
-        continue;
-
-      // we check directory instead of file as the file might or might not
-      // exist already as a link or not which complicates everything…
-      std::string dirname = flNotFile(filename);
-      if (unlikely(dirname.empty()))
+      if ((*I)->Complete == true || (*I)->Status != pkgAcquire::Item::StatIdle)

         continue;
         continue;

-      // translate relative to absolute for DirectoryExists
-      // FIXME: What about ../ and ./../ ?
-      if (dirname.substr(0,2) == "./")
-        dirname = SafeGetCWD() + dirname.substr(2);
-
-      if (DirectoryExists(dirname))
-        ;
-      else
-        continue; // assume it is created correctly by the acquire system

 
 

-      if (faccessat(-1, dirname.c_str(), R_OK | W_OK | X_OK, AT_EACCESS | AT_SYMLINK_NOFOLLOW) != 0)
+      // if destination file is inaccessible all hope is lost for privilege dropping
+      if (IsAccessibleBySandboxUser((*I)->DestFile, true) == false)

       {
         _error->WarningE("pkgAcquire::Run", _("Can't drop privileges for downloading as file '%s' couldn't be accessed by user '%s'."),
       {
         _error->WarningE("pkgAcquire::Run", _("Can't drop privileges for downloading as file '%s' couldn't be accessed by user '%s'."),

-              filename.c_str(), SandboxUser.c_str());
+              (*I)->DestFile.c_str(), SandboxUser.c_str());

         _config->Set("APT::Sandbox::User", "");
         break;
       }
         _config->Set("APT::Sandbox::User", "");
         break;
       }

+
+      // if its the source file (e.g. local sources) we might be lucky
+      // by dropping the dropping only for some methods.
+      URI const source = (*I)->DescURI();
+      if (source.Access == "file" || source.Access == "copy")
+      {
+        std::string const conf = "Binary::" + source.Access + "::APT::Sandbox::User";
+        if (_config->Exists(conf) == true)
+           continue;
+
+        if (IsAccessibleBySandboxUser(source.Path, false) == false)
+        {
+           _error->NoticeE("pkgAcquire::Run", _("Can't drop privileges for downloading as file '%s' couldn't be accessed by user '%s'."),
+                 source.Path.c_str(), SandboxUser.c_str());
+           _config->CndSet("Binary::file::APT::Sandbox::User", "root");
+           _config->CndSet("Binary::copy::APT::Sandbox::User", "root");
+        }
+      }

    }
 
    if (seteuid(old_euid) != 0)
    }
 
    if (seteuid(old_euid) != 0)

-      _error->Errno("seteuid", "seteuid %u failed", old_euid);
+      _error->FatalE("seteuid", "seteuid %u failed", old_euid);

    if (setegid(old_egid) != 0)
    if (setegid(old_egid) != 0)

-      _error->Errno("setegid", "setegid %u failed", old_egid);
+      _error->FatalE("setegid", "setegid %u failed", old_egid);
+   if (setgroups(old_gidlist_nr, old_gidlist.get()))
+      _error->FatalE("setgroups", "setgroups %u failed", 0);

 }
 pkgAcquire::RunResult pkgAcquire::Run(int PulseIntervall)
 {
 }
 pkgAcquire::RunResult pkgAcquire::Run(int PulseIntervall)
 {


@@ -549,7 +713,8 @@ pkgAcquire::RunResult pkgAcquire::Run(int PulseIntervall)
         break;
       }
 
         break;
       }
 

-      RunFds(&RFds,&WFds);
+      if(RunFdsSane(&RFds,&WFds) == false)
+         break;

 
       // Timeout, notify the log class
       if (Res == 0 || (Log != 0 && Log->Update == true))
 
       // Timeout, notify the log class
       if (Res == 0 || (Log != 0 && Log->Update == true))


@@ -633,6 +798,7 @@ bool pkgAcquire::Clean(string Dir)
       // Skip some files..
       if (strcmp(Dir->d_name,"lock") == 0 ||
          strcmp(Dir->d_name,"partial") == 0 ||
       // Skip some files..
       if (strcmp(Dir->d_name,"lock") == 0 ||
          strcmp(Dir->d_name,"partial") == 0 ||

+         strcmp(Dir->d_name,"lost+found") == 0 ||

          strcmp(Dir->d_name,".") == 0 ||
          strcmp(Dir->d_name,"..") == 0)
         continue;
          strcmp(Dir->d_name,".") == 0 ||
          strcmp(Dir->d_name,"..") == 0)
         continue;


@@ -645,7 +811,7 @@ bool pkgAcquire::Clean(string Dir)
       
       // Nothing found, nuke it
       if (I == Items.end())
       
       // Nothing found, nuke it
       if (I == Items.end())

-        unlink(Dir->d_name);
+        RemoveFile("Clean", Dir->d_name);

    };
    
    closedir(D);
    };
    
    closedir(D);


@@ -659,7 +825,7 @@ bool pkgAcquire::Clean(string Dir)
 /* This is the total number of bytes needed */
 APT_PURE unsigned long long pkgAcquire::TotalNeeded()
 {
 /* This is the total number of bytes needed */
 APT_PURE unsigned long long pkgAcquire::TotalNeeded()
 {

-   return std::accumulate(ItemsBegin(), ItemsEnd(), 0,
+   return std::accumulate(ItemsBegin(), ItemsEnd(), 0llu,

       [](unsigned long long const T, Item const * const I) {
         return T + I->FileSize;
    });
       [](unsigned long long const T, Item const * const I) {
         return T + I->FileSize;
    });


@@ -670,7 +836,7 @@ APT_PURE unsigned long long pkgAcquire::TotalNeeded()
 /* This is the number of bytes that is not local */
 APT_PURE unsigned long long pkgAcquire::FetchNeeded()
 {
 /* This is the number of bytes that is not local */
 APT_PURE unsigned long long pkgAcquire::FetchNeeded()
 {

-   return std::accumulate(ItemsBegin(), ItemsEnd(), 0,
+   return std::accumulate(ItemsBegin(), ItemsEnd(), 0llu,

       [](unsigned long long const T, Item const * const I) {
         if (I->Local == false)
            return T + I->FileSize;
       [](unsigned long long const T, Item const * const I) {
         if (I->Local == false)
            return T + I->FileSize;


@@ -684,7 +850,7 @@ APT_PURE unsigned long long pkgAcquire::FetchNeeded()
 /* This is the number of bytes that is not local */
 APT_PURE unsigned long long pkgAcquire::PartialPresent()
 {
 /* This is the number of bytes that is not local */
 APT_PURE unsigned long long pkgAcquire::PartialPresent()
 {

-   return std::accumulate(ItemsBegin(), ItemsEnd(), 0,
+   return std::accumulate(ItemsBegin(), ItemsEnd(), 0llu,

       [](unsigned long long const T, Item const * const I) {
         if (I->Local == false)
            return T + I->PartialSize;
       [](unsigned long long const T, Item const * const I) {
         if (I->Local == false)
            return T + I->PartialSize;


@@ -746,11 +912,11 @@ pkgAcquire::Queue::~Queue()
 /* */
 bool pkgAcquire::Queue::Enqueue(ItemDesc &Item)
 {
 /* */
 bool pkgAcquire::Queue::Enqueue(ItemDesc &Item)
 {

+   QItem **OptimalI = &Items;

    QItem **I = &Items;
    // move to the end of the queue and check for duplicates here
    QItem **I = &Items;
    // move to the end of the queue and check for duplicates here

-   HashStringList const hsl = Item.Owner->GetExpectedHashes();
-   for (; *I != 0; I = &(*I)->Next)
-      if (Item.URI == (*I)->URI || hsl == (*I)->Owner->GetExpectedHashes())
+   for (; *I != 0; ) {
+      if (Item.URI == (*I)->URI)

       {
         if (_config->FindB("Debug::pkgAcquire::Worker",false) == true)
            std::cerr << " @ Queue: Action combined for " << Item.URI << " and " << (*I)->URI << std::endl;
       {
         if (_config->FindB("Debug::pkgAcquire::Worker",false) == true)
            std::cerr << " @ Queue: Action combined for " << Item.URI << " and " << (*I)->URI << std::endl;


@@ -758,12 +924,22 @@ bool pkgAcquire::Queue::Enqueue(ItemDesc &Item)
         Item.Owner->Status = (*I)->Owner->Status;
         return false;
       }
         Item.Owner->Status = (*I)->Owner->Status;
         return false;
       }

+      // Determine the optimal position to insert: before anything with a
+      // higher priority.
+      int priority = (*I)->GetPriority();
+
+      I = &(*I)->Next;
+      if (priority >= Item.Owner->Priority()) {
+        OptimalI = I;
+      }
+   }
+

 
    // Create a new item
    QItem *Itm = new QItem;
    *Itm = Item;
 
    // Create a new item
    QItem *Itm = new QItem;
    *Itm = Item;

-   Itm->Next = 0;
-   *I = Itm;
+   Itm->Next = *OptimalI;
+   *OptimalI = Itm;

    
    Item.Owner->QueueCounter++;   
    if (Items->Next == 0)
    
    Item.Owner->QueueCounter++;   
    if (Items->Next == 0)


@@ -808,10 +984,20 @@ bool pkgAcquire::Queue::Startup()
    if (Workers == 0)
    {
       URI U(Name);
    if (Workers == 0)
    {
       URI U(Name);

-      pkgAcquire::MethodConfig *Cnf = Owner->GetConfig(U.Access);
-      if (Cnf == 0)
+      pkgAcquire::MethodConfig * const Cnf = Owner->GetConfig(U.Access);
+      if (unlikely(Cnf == nullptr))

         return false;
         return false;

-      
+
+      // now-running twin of the pkgAcquire::Enqueue call
+      for (QItem *I = Items; I != 0; )
+      {
+        auto const INext = I->Next;
+        for (auto &&O: I->Owners)
+           CheckForBadItemAndFailIt(O, Cnf, Owner->Log);
+        // if an item failed, it will be auto-dequeued invalidation our I here
+        I = INext;
+      }
+

       Workers = new Worker(this,Cnf,Owner->Log);
       Owner->Add(Workers);
       if (Workers->Start() == false)
       Workers = new Worker(this,Cnf,Owner->Log);
       Owner->Add(Workers);
       if (Workers->Start() == false)


@@ -903,16 +1089,24 @@ bool pkgAcquire::Queue::Cycle()
 
    // Look for a queable item
    QItem *I = Items;
 
    // Look for a queable item
    QItem *I = Items;

+   int ActivePriority = 0;

    while (PipeDepth < (signed)MaxPipeDepth)
    {
    while (PipeDepth < (signed)MaxPipeDepth)
    {

-      for (; I != 0; I = I->Next)
+      for (; I != 0; I = I->Next) {
+        if (I->Owner->Status == pkgAcquire::Item::StatFetching)
+           ActivePriority = std::max(ActivePriority, I->GetPriority());

         if (I->Owner->Status == pkgAcquire::Item::StatIdle)
            break;
         if (I->Owner->Status == pkgAcquire::Item::StatIdle)
            break;

+      }

 
       // Nothing to do, queue is idle.
       if (I == 0)
         return true;
 
 
       // Nothing to do, queue is idle.
       if (I == 0)
         return true;
 

+      // This item has a lower priority than stuff in the pipeline, pretend
+      // the queue is idle
+      if (I->GetPriority() < ActivePriority)
+        return true;

       I->Worker = Workers;
       for (auto const &O: I->Owners)
         O->Status = pkgAcquire::Item::StatFetching;
       I->Worker = Workers;
       for (auto const &O: I->Owners)
         O->Status = pkgAcquire::Item::StatFetching;


@@ -978,6 +1172,15 @@ APT_PURE unsigned long long pkgAcquire::Queue::QItem::GetMaximumSize() const      /*{
    return Maximum;
 }
                                                                        /*}}}*/
    return Maximum;
 }
                                                                        /*}}}*/

+APT_PURE int pkgAcquire::Queue::QItem::GetPriority() const             /*{{{*/
+{
+   int Priority = 0;
+   for (auto const &O: Owners)
+      Priority = std::max(Priority, O->Priority());
+
+   return Priority;
+}
+                                                                       /*}}}*/

 void pkgAcquire::Queue::QItem::SyncDestinationFiles() const            /*{{{*/
 {
    /* ensure that the first owner has the best partial file of all and
 void pkgAcquire::Queue::QItem::SyncDestinationFiles() const            /*{{{*/
 {
    /* ensure that the first owner has the best partial file of all and


@@ -993,15 +1196,15 @@ void pkgAcquire::Queue::QItem::SyncDestinationFiles() const              /*{{{*/
       if (lstat((*O)->DestFile.c_str(),&file) == 0)
       {
         if ((file.st_mode & S_IFREG) == 0)
       if (lstat((*O)->DestFile.c_str(),&file) == 0)
       {
         if ((file.st_mode & S_IFREG) == 0)

-           unlink((*O)->DestFile.c_str());
+           RemoveFile("SyncDestinationFiles", (*O)->DestFile);

         else if (supersize < file.st_size)
         {
            supersize = file.st_size;
         else if (supersize < file.st_size)
         {
            supersize = file.st_size;

-           unlink(superfile.c_str());
+           RemoveFile("SyncDestinationFiles", superfile);

            rename((*O)->DestFile.c_str(), superfile.c_str());
         }
         else
            rename((*O)->DestFile.c_str(), superfile.c_str());
         }
         else

-           unlink((*O)->DestFile.c_str());
+           RemoveFile("SyncDestinationFiles", (*O)->DestFile);

         if (symlink(superfile.c_str(), (*O)->DestFile.c_str()) != 0)
         {
            ; // not a problem per-se and no real alternative
         if (symlink(superfile.c_str(), (*O)->DestFile.c_str()) != 0)
         {
            ; // not a problem per-se and no real alternative


@@ -1039,11 +1242,11 @@ bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
    CurrentBytes = 0;
    TotalItems = 0;
    CurrentItems = 0;
    CurrentBytes = 0;
    TotalItems = 0;
    CurrentItems = 0;

-   
+

    // Compute the total number of bytes to fetch
    unsigned int Unknown = 0;
    unsigned int Count = 0;
    // Compute the total number of bytes to fetch
    unsigned int Unknown = 0;
    unsigned int Count = 0;

-   bool UnfetchedReleaseFiles = false;
+   bool ExpectAdditionalItems = false;

    for (pkgAcquire::ItemCIterator I = Owner->ItemsBegin(); 
         I != Owner->ItemsEnd();
        ++I, ++Count)
    for (pkgAcquire::ItemCIterator I = Owner->ItemsBegin(); 
         I != Owner->ItemsEnd();
        ++I, ++Count)


@@ -1051,17 +1254,10 @@ bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
       TotalItems++;
       if ((*I)->Status == pkgAcquire::Item::StatDone)
         ++CurrentItems;
       TotalItems++;
       if ((*I)->Status == pkgAcquire::Item::StatDone)
         ++CurrentItems;

-      
-      // Totally ignore local items
-      if ((*I)->Local == true)
-        continue;

 
 

-      // see if the method tells us to expect more
-      TotalItems += (*I)->ExpectedAdditionalItems;
-
-      // check if there are unfetched Release files
-      if ((*I)->Complete == false && (*I)->ExpectedAdditionalItems > 0)
-         UnfetchedReleaseFiles = true;
+      // do we expect to acquire more files than we know of yet?
+      if ((*I)->ExpectedAdditionalItems > 0)
+         ExpectAdditionalItems = true;

 
       TotalBytes += (*I)->FileSize;
       if ((*I)->Complete == true)
 
       TotalBytes += (*I)->FileSize;
       if ((*I)->Complete == true)


@@ -1069,7 +1265,7 @@ bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
       if ((*I)->FileSize == 0 && (*I)->Complete == false)
         ++Unknown;
    }
       if ((*I)->FileSize == 0 && (*I)->Complete == false)
         ++Unknown;
    }

-   
+

    // Compute the current completion
    unsigned long long ResumeSize = 0;
    for (pkgAcquire::Worker *I = Owner->WorkersBegin(); I != 0;
    // Compute the current completion
    unsigned long long ResumeSize = 0;
    for (pkgAcquire::Worker *I = Owner->WorkersBegin(); I != 0;


@@ -1097,12 +1293,6 @@ bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
    if (CurrentBytes > TotalBytes)
       CurrentBytes = TotalBytes;
 
    if (CurrentBytes > TotalBytes)
       CurrentBytes = TotalBytes;
 

-   // debug
-   if (_config->FindB("Debug::acquire::progress", false) == true)
-      std::clog << " Bytes: " 
-                << SizeToStr(CurrentBytes) << " / " << SizeToStr(TotalBytes) 
-                << std::endl;
-   

    // Compute the CPS
    struct timeval NewTime;
    gettimeofday(&NewTime,0);
    // Compute the CPS
    struct timeval NewTime;
    gettimeofday(&NewTime,0);


@@ -1124,12 +1314,27 @@ bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
 
    double const OldPercent = Percent;
    // calculate the percentage, if we have too little data assume 1%
 
    double const OldPercent = Percent;
    // calculate the percentage, if we have too little data assume 1%

-   if (TotalBytes > 0 && UnfetchedReleaseFiles)
+   if (ExpectAdditionalItems)

       Percent = 0;
    else
       // use both files and bytes because bytes can be unreliable
       Percent = (0.8 * (CurrentBytes/float(TotalBytes)*100.0) +
                  0.2 * (CurrentItems/float(TotalItems)*100.0));
       Percent = 0;
    else
       // use both files and bytes because bytes can be unreliable
       Percent = (0.8 * (CurrentBytes/float(TotalBytes)*100.0) +
                  0.2 * (CurrentItems/float(TotalItems)*100.0));

+
+   // debug
+   if (_config->FindB("Debug::acquire::progress", false) == true)
+   {
+      std::clog
+         << "["
+         << std::setw(5) << std::setprecision(4) << std::showpoint << Percent 
+         << "]"
+         << " Bytes: "
+         << SizeToStr(CurrentBytes) << " / " << SizeToStr(TotalBytes)
+         << " # Files: "
+         << CurrentItems << " / " << TotalItems
+         << std::endl;
+   }
+

    double const DiffPercent = Percent - OldPercent;
    if (DiffPercent < 0.001 && _config->FindB("Acquire::Progress::Diffpercent", false) == true)
       return true;
    double const DiffPercent = Percent - OldPercent;
    if (DiffPercent < 0.001 && _config->FindB("Acquire::Progress::Diffpercent", false) == true)
       return true;


@@ -1152,13 +1357,12 @@ bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
         snprintf(msg,sizeof(msg), _("Retrieving file %li of %li"), i, TotalItems);
 
       // build the status str
         snprintf(msg,sizeof(msg), _("Retrieving file %li of %li"), i, TotalItems);
 
       // build the status str

-      status << "dlstatus:" << i
-             << ":"  << std::setprecision(3) << Percent
-             << ":" << msg
-             << endl;
-
-      std::string const dlstatus = status.str();
-      FileFd::Write(fd, dlstatus.c_str(), dlstatus.size());
+      std::ostringstream str;
+      str.imbue(std::locale::classic());
+      str.precision(4);
+      str << "dlstatus" << ':' << std::fixed << i << ':' << Percent << ':' << msg << '\n';
+      auto const dlstatus = str.str();
+      FileFd::Write(fd, dlstatus.data(), dlstatus.size());

    }
 
    return true;
    }
 
    return true;