apt-pkg/acquire.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: acquire.cc,v 1.50 2004/03/17 05:17:11 mdz Exp $
   4 /* ######################################################################
   5
   6    Acquire - File Acquiration
   7
   8    The core element for the schedule system is the concept of a named
   9    queue. Each queue is unique and each queue has a name derived from the
  10    URI. The degree of paralization can be controlled by how the queue
  11    name is derived from the URI.
  12
  13    ##################################################################### */
  14                                                                         /*}}}*/
  15 // Include Files                                                        /*{{{*/
  16 #include <config.h>
  17
  18 #include <apt-pkg/acquire.h>
  19 #include <apt-pkg/acquire-item.h>
  20 #include <apt-pkg/acquire-worker.h>
  21 #include <apt-pkg/configuration.h>
  22 #include <apt-pkg/error.h>
  23 #include <apt-pkg/strutl.h>
  24 #include <apt-pkg/fileutl.h>
  25
  26 #include <algorithm>
  27 #include <numeric>
  28 #include <string>
  29 #include <vector>
  30 #include <iostream>
  31 #include <sstream>
  32 #include <iomanip>
  33 #include <memory>
  34
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <unistd.h>
  39 #include <fcntl.h>
  40 #include <pwd.h>
  41 #include <grp.h>
  42 #include <dirent.h>
  43 #include <sys/time.h>
  44 #include <sys/select.h>
  45 #include <errno.h>
  46 #include <sys/stat.h>
  47
  48 #include <apti18n.h>
  49                                                                         /*}}}*/
  50
  51 using namespace std;
  52
  53 // Acquire::pkgAcquire - Constructor                                    /*{{{*/
  54 // ---------------------------------------------------------------------
  55 /* We grab some runtime state from the configuration space */
  56 pkgAcquire::pkgAcquire() : LockFD(-1), d(NULL), Queues(0), Workers(0), Configs(0), Log(NULL), ToFetch(0),
  57                            Debug(_config->FindB("Debug::pkgAcquire",false)),
  58                            Running(false)
  59 {
  60    Initialize();
  61 }
  62 pkgAcquire::pkgAcquire(pkgAcquireStatus *Progress) : LockFD(-1), d(NULL), Queues(0), Workers(0),
  63                            Configs(0), Log(NULL), ToFetch(0),
  64                            Debug(_config->FindB("Debug::pkgAcquire",false)),
  65                            Running(false)
  66 {
  67    Initialize();
  68    SetLog(Progress);
  69 }
  70 void pkgAcquire::Initialize()
  71 {
  72    string const Mode = _config->Find("Acquire::Queue-Mode","host");
  73    if (strcasecmp(Mode.c_str(),"host") == 0)
  74       QueueMode = QueueHost;
  75    if (strcasecmp(Mode.c_str(),"access") == 0)
  76       QueueMode = QueueAccess;
  77
  78    // chown the auth.conf file as it will be accessed by our methods
  79    std::string const SandboxUser = _config->Find("APT::Sandbox::User");
  80    if (getuid() == 0 && SandboxUser.empty() == false && SandboxUser != "root") // if we aren't root, we can't chown, so don't try it
  81    {
  82       struct passwd const * const pw = getpwnam(SandboxUser.c_str());
  83       struct group const * const gr = getgrnam("root");
  84       if (pw != NULL && gr != NULL)
  85       {
  86          std::string const AuthConf = _config->FindFile("Dir::Etc::netrc");
  87          if(AuthConf.empty() == false && RealFileExists(AuthConf) &&
  88                chown(AuthConf.c_str(), pw->pw_uid, gr->gr_gid) != 0)
  89             _error->WarningE("SetupAPTPartialDirectory", "chown to %s:root of file %s failed", SandboxUser.c_str(), AuthConf.c_str());
  90       }
  91    }
  92 }
  93                                                                         /*}}}*/
  94 // Acquire::GetLock - lock directory and prepare for action             /*{{{*/
  95 static bool SetupAPTPartialDirectory(std::string const &grand, std::string const &parent)
  96 {
  97    std::string const partial = parent + "partial";
  98    mode_t const mode = umask(S_IWGRP | S_IWOTH);
  99    bool const creation_fail = (CreateAPTDirectoryIfNeeded(grand, partial) == false &&
 100          CreateAPTDirectoryIfNeeded(parent, partial) == false);
 101    umask(mode);
 102    if (creation_fail == true)
 103       return false;
 104
 105    std::string const SandboxUser = _config->Find("APT::Sandbox::User");
 106    if (getuid() == 0 && SandboxUser.empty() == false && SandboxUser != "root") // if we aren't root, we can't chown, so don't try it
 107    {
 108       struct passwd const * const pw = getpwnam(SandboxUser.c_str());
 109       struct group const * const gr = getgrnam("root");
 110       if (pw != NULL && gr != NULL)
 111       {
 112          // chown the partial dir
 113          if(chown(partial.c_str(), pw->pw_uid, gr->gr_gid) != 0)
 114             _error->WarningE("SetupAPTPartialDirectory", "chown to %s:root of directory %s failed", SandboxUser.c_str(), partial.c_str());
 115       }
 116    }
 117    if (chmod(partial.c_str(), 0700) != 0)
 118       _error->WarningE("SetupAPTPartialDirectory", "chmod 0700 of directory %s failed", partial.c_str());
 119
 120    return true;
 121 }
 122 bool pkgAcquire::Setup(pkgAcquireStatus *Progress, string const &Lock)
 123 {
 124    Log = Progress;
 125    if (Lock.empty())
 126    {
 127       string const listDir = _config->FindDir("Dir::State::lists");
 128       if (SetupAPTPartialDirectory(_config->FindDir("Dir::State"), listDir) == false)
 129          return _error->Errno("Acquire", _("List directory %spartial is missing."), listDir.c_str());
 130       string const archivesDir = _config->FindDir("Dir::Cache::Archives");
 131       if (SetupAPTPartialDirectory(_config->FindDir("Dir::Cache"), archivesDir) == false)
 132          return _error->Errno("Acquire", _("Archives directory %spartial is missing."), archivesDir.c_str());
 133       return true;
 134    }
 135    return GetLock(Lock);
 136 }
 137 bool pkgAcquire::GetLock(std::string const &Lock)
 138 {
 139    if (Lock.empty() == true)
 140       return false;
 141
 142    // check for existence and possibly create auxiliary directories
 143    string const listDir = _config->FindDir("Dir::State::lists");
 144    string const archivesDir = _config->FindDir("Dir::Cache::Archives");
 145
 146    if (Lock == listDir)
 147    {
 148       if (SetupAPTPartialDirectory(_config->FindDir("Dir::State"), listDir) == false)
 149          return _error->Errno("Acquire", _("List directory %spartial is missing."), listDir.c_str());
 150    }
 151    if (Lock == archivesDir)
 152    {
 153       if (SetupAPTPartialDirectory(_config->FindDir("Dir::Cache"), archivesDir) == false)
 154          return _error->Errno("Acquire", _("Archives directory %spartial is missing."), archivesDir.c_str());
 155    }
 156
 157    if (_config->FindB("Debug::NoLocking", false) == true)
 158       return true;
 159
 160    // Lock the directory this acquire object will work in
 161    if (LockFD != -1)
 162       close(LockFD);
 163    LockFD = ::GetLock(flCombine(Lock, "lock"));
 164    if (LockFD == -1)
 165       return _error->Error(_("Unable to lock directory %s"), Lock.c_str());
 166
 167    return true;
 168 }
 169                                                                         /*}}}*/
 170 // Acquire::~pkgAcquire - Destructor                                    /*{{{*/
 171 // ---------------------------------------------------------------------
 172 /* Free our memory, clean up the queues (destroy the workers) */
 173 pkgAcquire::~pkgAcquire()
 174 {
 175    Shutdown();
 176
 177    if (LockFD != -1)
 178       close(LockFD);
 179
 180    while (Configs != 0)
 181    {
 182       MethodConfig *Jnk = Configs;
 183       Configs = Configs->Next;
 184       delete Jnk;
 185    }
 186 }
 187                                                                         /*}}}*/
 188 // Acquire::Shutdown - Clean out the acquire object                     /*{{{*/
 189 // ---------------------------------------------------------------------
 190 /* */
 191 void pkgAcquire::Shutdown()
 192 {
 193    while (Items.empty() == false)
 194    {
 195       if (Items[0]->Status == Item::StatFetching)
 196          Items[0]->Status = Item::StatError;
 197       delete Items[0];
 198    }
 199
 200    while (Queues != 0)
 201    {
 202       Queue *Jnk = Queues;
 203       Queues = Queues->Next;
 204       delete Jnk;
 205    }
 206 }
 207                                                                         /*}}}*/
 208 // Acquire::Add - Add a new item                                        /*{{{*/
 209 // ---------------------------------------------------------------------
 210 /* This puts an item on the acquire list. This list is mainly for tracking
 211    item status */
 212 void pkgAcquire::Add(Item *Itm)
 213 {
 214    Items.push_back(Itm);
 215 }
 216                                                                         /*}}}*/
 217 // Acquire::Remove - Remove a item                                      /*{{{*/
 218 // ---------------------------------------------------------------------
 219 /* Remove an item from the acquire list. This is usually not used.. */
 220 void pkgAcquire::Remove(Item *Itm)
 221 {
 222    Dequeue(Itm);
 223
 224    for (ItemIterator I = Items.begin(); I != Items.end();)
 225    {
 226       if (*I == Itm)
 227       {
 228          Items.erase(I);
 229          I = Items.begin();
 230       }
 231       else
 232          ++I;
 233    }
 234 }
 235                                                                         /*}}}*/
 236 // Acquire::Add - Add a worker                                          /*{{{*/
 237 // ---------------------------------------------------------------------
 238 /* A list of workers is kept so that the select loop can direct their FD
 239    usage. */
 240 void pkgAcquire::Add(Worker *Work)
 241 {
 242    Work->NextAcquire = Workers;
 243    Workers = Work;
 244 }
 245                                                                         /*}}}*/
 246 // Acquire::Remove - Remove a worker                                    /*{{{*/
 247 // ---------------------------------------------------------------------
 248 /* A worker has died. This can not be done while the select loop is running
 249    as it would require that RunFds could handling a changing list state and
 250    it can't.. */
 251 void pkgAcquire::Remove(Worker *Work)
 252 {
 253    if (Running == true)
 254       abort();
 255
 256    Worker **I = &Workers;
 257    for (; *I != 0;)
 258    {
 259       if (*I == Work)
 260          *I = (*I)->NextAcquire;
 261       else
 262          I = &(*I)->NextAcquire;
 263    }
 264 }
 265                                                                         /*}}}*/
 266 // Acquire::Enqueue - Queue an URI for fetching                         /*{{{*/
 267 // ---------------------------------------------------------------------
 268 /* This is the entry point for an item. An item calls this function when
 269    it is constructed which creates a queue (based on the current queue
 270    mode) and puts the item in that queue. If the system is running then
 271    the queue might be started. */
 272 void pkgAcquire::Enqueue(ItemDesc &Item)
 273 {
 274    // Determine which queue to put the item in
 275    const MethodConfig *Config;
 276    string Name = QueueName(Item.URI,Config);
 277    if (Name.empty() == true)
 278       return;
 279
 280    // Find the queue structure
 281    Queue *I = Queues;
 282    for (; I != 0 && I->Name != Name; I = I->Next);
 283    if (I == 0)
 284    {
 285       I = new Queue(Name,this);
 286       I->Next = Queues;
 287       Queues = I;
 288
 289       if (Running == true)
 290          I->Startup();
 291    }
 292
 293    // See if this is a local only URI
 294    if (Config->LocalOnly == true && Item.Owner->Complete == false)
 295       Item.Owner->Local = true;
 296    Item.Owner->Status = Item::StatIdle;
 297
 298    // Queue it into the named queue
 299    if(I->Enqueue(Item))
 300       ToFetch++;
 301
 302    // Some trace stuff
 303    if (Debug == true)
 304    {
 305       clog << "Fetching " << Item.URI << endl;
 306       clog << " to " << Item.Owner->DestFile << endl;
 307       clog << " Queue is: " << Name << endl;
 308    }
 309 }
 310                                                                         /*}}}*/
 311 // Acquire::Dequeue - Remove an item from all queues                    /*{{{*/
 312 // ---------------------------------------------------------------------
 313 /* This is called when an item is finished being fetched. It removes it
 314    from all the queues */
 315 void pkgAcquire::Dequeue(Item *Itm)
 316 {
 317    Queue *I = Queues;
 318    bool Res = false;
 319    if (Debug == true)
 320       clog << "Dequeuing " << Itm->DestFile << endl;
 321
 322    for (; I != 0; I = I->Next)
 323    {
 324       if (I->Dequeue(Itm))
 325       {
 326          Res = true;
 327          if (Debug == true)
 328             clog << "Dequeued from " << I->Name << endl;
 329       }
 330    }
 331
 332    if (Res == true)
 333       ToFetch--;
 334 }
 335                                                                         /*}}}*/
 336 // Acquire::QueueName - Return the name of the queue for this URI       /*{{{*/
 337 // ---------------------------------------------------------------------
 338 /* The string returned depends on the configuration settings and the
 339    method parameters. Given something like http://foo.org/bar it can
 340    return http://foo.org or http */
 341 string pkgAcquire::QueueName(string Uri,MethodConfig const *&Config)
 342 {
 343    URI U(Uri);
 344
 345    Config = GetConfig(U.Access);
 346    if (Config == 0)
 347       return string();
 348
 349    /* Single-Instance methods get exactly one queue per URI. This is
 350       also used for the Access queue method  */
 351    if (Config->SingleInstance == true || QueueMode == QueueAccess)
 352       return U.Access;
 353
 354    string AccessSchema = U.Access + ':',
 355         FullQueueName = AccessSchema + U.Host;
 356    unsigned int Instances = 0, SchemaLength = AccessSchema.length();
 357
 358    Queue *I = Queues;
 359    for (; I != 0; I = I->Next) {
 360       // if the queue already exists, re-use it
 361       if (I->Name == FullQueueName)
 362          return FullQueueName;
 363
 364       if (I->Name.compare(0, SchemaLength, AccessSchema) == 0)
 365          Instances++;
 366    }
 367
 368    if (Debug) {
 369       clog << "Found " << Instances << " instances of " << U.Access << endl;
 370    }
 371
 372    if (Instances >= (unsigned int)_config->FindI("Acquire::QueueHost::Limit",10))
 373       return U.Access;
 374
 375    return FullQueueName;
 376 }
 377                                                                         /*}}}*/
 378 // Acquire::GetConfig - Fetch the configuration information             /*{{{*/
 379 // ---------------------------------------------------------------------
 380 /* This locates the configuration structure for an access method. If
 381    a config structure cannot be found a Worker will be created to
 382    retrieve it */
 383 pkgAcquire::MethodConfig *pkgAcquire::GetConfig(string Access)
 384 {
 385    // Search for an existing config
 386    MethodConfig *Conf;
 387    for (Conf = Configs; Conf != 0; Conf = Conf->Next)
 388       if (Conf->Access == Access)
 389          return Conf;
 390
 391    // Create the new config class
 392    Conf = new MethodConfig;
 393    Conf->Access = Access;
 394    Conf->Next = Configs;
 395    Configs = Conf;
 396
 397    // Create the worker to fetch the configuration
 398    Worker Work(Conf);
 399    if (Work.Start() == false)
 400       return 0;
 401
 402    /* if a method uses DownloadLimit, we switch to SingleInstance mode */
 403    if(_config->FindI("Acquire::"+Access+"::Dl-Limit",0) > 0)
 404       Conf->SingleInstance = true;
 405
 406    return Conf;
 407 }
 408                                                                         /*}}}*/
 409 // Acquire::SetFds - Deal with readable FDs                             /*{{{*/
 410 // ---------------------------------------------------------------------
 411 /* Collect FDs that have activity monitors into the fd sets */
 412 void pkgAcquire::SetFds(int &Fd,fd_set *RSet,fd_set *WSet)
 413 {
 414    for (Worker *I = Workers; I != 0; I = I->NextAcquire)
 415    {
 416       if (I->InReady == true && I->InFd >= 0)
 417       {
 418          if (Fd < I->InFd)
 419             Fd = I->InFd;
 420          FD_SET(I->InFd,RSet);
 421       }
 422       if (I->OutReady == true && I->OutFd >= 0)
 423       {
 424          if (Fd < I->OutFd)
 425             Fd = I->OutFd;
 426          FD_SET(I->OutFd,WSet);
 427       }
 428    }
 429 }
 430                                                                         /*}}}*/
 431 // Acquire::RunFds - Deal with active FDs                               /*{{{*/
 432 // ---------------------------------------------------------------------
 433 /* Dispatch active FDs over to the proper workers. It is very important
 434    that a worker never be erased while this is running! The queue class
 435    should never erase a worker except during shutdown processing. */
 436 void pkgAcquire::RunFds(fd_set *RSet,fd_set *WSet)
 437 {
 438    for (Worker *I = Workers; I != 0; I = I->NextAcquire)
 439    {
 440       if (I->InFd >= 0 && FD_ISSET(I->InFd,RSet) != 0)
 441          I->InFdReady();
 442       if (I->OutFd >= 0 && FD_ISSET(I->OutFd,WSet) != 0)
 443          I->OutFdReady();
 444    }
 445 }
 446                                                                         /*}}}*/
 447 // Acquire::Run - Run the fetch sequence                                /*{{{*/
 448 // ---------------------------------------------------------------------
 449 /* This runs the queues. It manages a select loop for all of the
 450    Worker tasks. The workers interact with the queues and items to
 451    manage the actual fetch. */
 452 static bool IsAccessibleBySandboxUser(std::string const &filename, bool const ReadWrite)
 453 {
 454    // you would think this is easily to answer with faccessat, right? Wrong!
 455    // It e.g. gets groups wrong, so the only thing which works reliable is trying
 456    // to open the file we want to open later on…
 457    if (unlikely(filename.empty()))
 458       return true;
 459
 460    if (ReadWrite == false)
 461    {
 462       errno = 0;
 463       // can we read a file? Note that non-existing files are "fine"
 464       int const fd = open(filename.c_str(), O_RDONLY | O_CLOEXEC);
 465       if (fd == -1 && errno == EACCES)
 466          return false;
 467       close(fd);
 468       return true;
 469    }
 470    else
 471    {
 472       // the file might not exist yet and even if it does we will fix permissions,
 473       // so important is here just that the directory it is in allows that
 474       std::string const dirname = flNotFile(filename);
 475       if (unlikely(dirname.empty()))
 476          return true;
 477
 478       char const * const filetag = ".apt-acquire-privs-test.XXXXXX";
 479       std::string const tmpfile_tpl = flCombine(dirname, filetag);
 480       std::unique_ptr<char, decltype(std::free) *> tmpfile { strdup(tmpfile_tpl.c_str()), std::free };
 481       int const fd = mkstemp(tmpfile.get());
 482       if (fd == -1 && errno == EACCES)
 483          return false;
 484       RemoveFile("IsAccessibleBySandboxUser", tmpfile.get());
 485       close(fd);
 486       return true;
 487    }
 488 }
 489 static void CheckDropPrivsMustBeDisabled(pkgAcquire const &Fetcher)
 490 {
 491    if(getuid() != 0)
 492       return;
 493
 494    std::string const SandboxUser = _config->Find("APT::Sandbox::User");
 495    if (SandboxUser.empty() || SandboxUser == "root")
 496       return;
 497
 498    struct passwd const * const pw = getpwnam(SandboxUser.c_str());
 499    if (pw == NULL)
 500       return;
 501
 502    gid_t const old_euid = geteuid();
 503    gid_t const old_egid = getegid();
 504
 505    long const ngroups_max = sysconf(_SC_NGROUPS_MAX);
 506    std::unique_ptr<gid_t[]> old_gidlist(new gid_t[ngroups_max]);
 507    if (unlikely(old_gidlist == NULL))
 508       return;
 509    ssize_t old_gidlist_nr;
 510    if ((old_gidlist_nr = getgroups(ngroups_max, old_gidlist.get())) < 0)
 511    {
 512       _error->FatalE("getgroups", "getgroups %lu failed", ngroups_max);
 513       old_gidlist[0] = 0;
 514       old_gidlist_nr = 1;
 515    }
 516    if (setgroups(1, &pw->pw_gid))
 517       _error->FatalE("setgroups", "setgroups %u failed", pw->pw_gid);
 518
 519    if (setegid(pw->pw_gid) != 0)
 520       _error->FatalE("setegid", "setegid %u failed", pw->pw_gid);
 521    if (seteuid(pw->pw_uid) != 0)
 522       _error->FatalE("seteuid", "seteuid %u failed", pw->pw_uid);
 523
 524    for (pkgAcquire::ItemCIterator I = Fetcher.ItemsBegin();
 525         I != Fetcher.ItemsEnd(); ++I)
 526    {
 527       // no need to drop privileges for a complete file
 528       if ((*I)->Complete == true)
 529          continue;
 530
 531       // if destination file is inaccessible all hope is lost for privilege dropping
 532       if (IsAccessibleBySandboxUser((*I)->DestFile, true) == false)
 533       {
 534          _error->WarningE("pkgAcquire::Run", _("Can't drop privileges for downloading as file '%s' couldn't be accessed by user '%s'."),
 535                (*I)->DestFile.c_str(), SandboxUser.c_str());
 536          _config->Set("APT::Sandbox::User", "");
 537          break;
 538       }
 539
 540       // if its the source file (e.g. local sources) we might be lucky
 541       // by dropping the dropping only for some methods.
 542       URI const source = (*I)->DescURI();
 543       if (source.Access == "file" || source.Access == "copy")
 544       {
 545          std::string const conf = "Binary::" + source.Access + "::APT::Sandbox::User";
 546          if (_config->Exists(conf) == true)
 547             continue;
 548
 549          if (IsAccessibleBySandboxUser(source.Path, false) == false)
 550          {
 551             _error->NoticeE("pkgAcquire::Run", _("Can't drop privileges for downloading as file '%s' couldn't be accessed by user '%s'."),
 552                   source.Path.c_str(), SandboxUser.c_str());
 553             _config->CndSet("Binary::file::APT::Sandbox::User", "root");
 554             _config->CndSet("Binary::copy::APT::Sandbox::User", "root");
 555          }
 556       }
 557    }
 558
 559    if (seteuid(old_euid) != 0)
 560       _error->FatalE("seteuid", "seteuid %u failed", old_euid);
 561    if (setegid(old_egid) != 0)
 562       _error->FatalE("setegid", "setegid %u failed", old_egid);
 563    if (setgroups(old_gidlist_nr, old_gidlist.get()))
 564       _error->FatalE("setgroups", "setgroups %u failed", 0);
 565 }
 566 pkgAcquire::RunResult pkgAcquire::Run(int PulseIntervall)
 567 {
 568    _error->PushToStack();
 569    CheckDropPrivsMustBeDisabled(*this);
 570
 571    Running = true;
 572
 573    for (Queue *I = Queues; I != 0; I = I->Next)
 574       I->Startup();
 575
 576    if (Log != 0)
 577       Log->Start();
 578
 579    bool WasCancelled = false;
 580
 581    // Run till all things have been acquired
 582    struct timeval tv;
 583    tv.tv_sec = 0;
 584    tv.tv_usec = PulseIntervall;
 585    while (ToFetch > 0)
 586    {
 587       fd_set RFds;
 588       fd_set WFds;
 589       int Highest = 0;
 590       FD_ZERO(&RFds);
 591       FD_ZERO(&WFds);
 592       SetFds(Highest,&RFds,&WFds);
 593
 594       int Res;
 595       do
 596       {
 597          Res = select(Highest+1,&RFds,&WFds,0,&tv);
 598       }
 599       while (Res < 0 && errno == EINTR);
 600
 601       if (Res < 0)
 602       {
 603          _error->Errno("select","Select has failed");
 604          break;
 605       }
 606
 607       RunFds(&RFds,&WFds);
 608
 609       // Timeout, notify the log class
 610       if (Res == 0 || (Log != 0 && Log->Update == true))
 611       {
 612          tv.tv_usec = PulseIntervall;
 613          for (Worker *I = Workers; I != 0; I = I->NextAcquire)
 614             I->Pulse();
 615          if (Log != 0 && Log->Pulse(this) == false)
 616          {
 617             WasCancelled = true;
 618             break;
 619          }
 620       }
 621    }
 622
 623    if (Log != 0)
 624       Log->Stop();
 625
 626    // Shut down the acquire bits
 627    Running = false;
 628    for (Queue *I = Queues; I != 0; I = I->Next)
 629       I->Shutdown(false);
 630
 631    // Shut down the items
 632    for (ItemIterator I = Items.begin(); I != Items.end(); ++I)
 633       (*I)->Finished();
 634
 635    bool const newError = _error->PendingError();
 636    _error->MergeWithStack();
 637    if (newError)
 638       return Failed;
 639    if (WasCancelled)
 640       return Cancelled;
 641    return Continue;
 642 }
 643                                                                         /*}}}*/
 644 // Acquire::Bump - Called when an item is dequeued                      /*{{{*/
 645 // ---------------------------------------------------------------------
 646 /* This routine bumps idle queues in hopes that they will be able to fetch
 647    the dequeued item */
 648 void pkgAcquire::Bump()
 649 {
 650    for (Queue *I = Queues; I != 0; I = I->Next)
 651       I->Bump();
 652 }
 653                                                                         /*}}}*/
 654 // Acquire::WorkerStep - Step to the next worker                        /*{{{*/
 655 // ---------------------------------------------------------------------
 656 /* Not inlined to advoid including acquire-worker.h */
 657 pkgAcquire::Worker *pkgAcquire::WorkerStep(Worker *I)
 658 {
 659    return I->NextAcquire;
 660 }
 661                                                                         /*}}}*/
 662 // Acquire::Clean - Cleans a directory                                  /*{{{*/
 663 // ---------------------------------------------------------------------
 664 /* This is a bit simplistic, it looks at every file in the dir and sees
 665    if it is part of the download set. */
 666 bool pkgAcquire::Clean(string Dir)
 667 {
 668    // non-existing directories are by definition clean…
 669    if (DirectoryExists(Dir) == false)
 670       return true;
 671
 672    if(Dir == "/")
 673       return _error->Error(_("Clean of %s is not supported"), Dir.c_str());
 674
 675    DIR *D = opendir(Dir.c_str());
 676    if (D == 0)
 677       return _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
 678
 679    string StartDir = SafeGetCWD();
 680    if (chdir(Dir.c_str()) != 0)
 681    {
 682       closedir(D);
 683       return _error->Errno("chdir",_("Unable to change to %s"),Dir.c_str());
 684    }
 685
 686    for (struct dirent *Dir = readdir(D); Dir != 0; Dir = readdir(D))
 687    {
 688       // Skip some files..
 689       if (strcmp(Dir->d_name,"lock") == 0 ||
 690           strcmp(Dir->d_name,"partial") == 0 ||
 691           strcmp(Dir->d_name,"lost+found") == 0 ||
 692           strcmp(Dir->d_name,".") == 0 ||
 693           strcmp(Dir->d_name,"..") == 0)
 694          continue;
 695
 696       // Look in the get list
 697       ItemCIterator I = Items.begin();
 698       for (; I != Items.end(); ++I)
 699          if (flNotDir((*I)->DestFile) == Dir->d_name)
 700             break;
 701
 702       // Nothing found, nuke it
 703       if (I == Items.end())
 704          RemoveFile("Clean", Dir->d_name);
 705    };
 706
 707    closedir(D);
 708    if (chdir(StartDir.c_str()) != 0)
 709       return _error->Errno("chdir",_("Unable to change to %s"),StartDir.c_str());
 710    return true;
 711 }
 712                                                                         /*}}}*/
 713 // Acquire::TotalNeeded - Number of bytes to fetch                      /*{{{*/
 714 // ---------------------------------------------------------------------
 715 /* This is the total number of bytes needed */
 716 APT_PURE unsigned long long pkgAcquire::TotalNeeded()
 717 {
 718    return std::accumulate(ItemsBegin(), ItemsEnd(), 0,
 719       [](unsigned long long const T, Item const * const I) {
 720          return T + I->FileSize;
 721    });
 722 }
 723                                                                         /*}}}*/
 724 // Acquire::FetchNeeded - Number of bytes needed to get                 /*{{{*/
 725 // ---------------------------------------------------------------------
 726 /* This is the number of bytes that is not local */
 727 APT_PURE unsigned long long pkgAcquire::FetchNeeded()
 728 {
 729    return std::accumulate(ItemsBegin(), ItemsEnd(), 0,
 730       [](unsigned long long const T, Item const * const I) {
 731          if (I->Local == false)
 732             return T + I->FileSize;
 733          else
 734             return T;
 735    });
 736 }
 737                                                                         /*}}}*/
 738 // Acquire::PartialPresent - Number of partial bytes we already have    /*{{{*/
 739 // ---------------------------------------------------------------------
 740 /* This is the number of bytes that is not local */
 741 APT_PURE unsigned long long pkgAcquire::PartialPresent()
 742 {
 743    return std::accumulate(ItemsBegin(), ItemsEnd(), 0,
 744       [](unsigned long long const T, Item const * const I) {
 745          if (I->Local == false)
 746             return T + I->PartialSize;
 747          else
 748             return T;
 749    });
 750 }
 751                                                                         /*}}}*/
 752 // Acquire::UriBegin - Start iterator for the uri list                  /*{{{*/
 753 // ---------------------------------------------------------------------
 754 /* */
 755 pkgAcquire::UriIterator pkgAcquire::UriBegin()
 756 {
 757    return UriIterator(Queues);
 758 }
 759                                                                         /*}}}*/
 760 // Acquire::UriEnd - End iterator for the uri list                      /*{{{*/
 761 // ---------------------------------------------------------------------
 762 /* */
 763 pkgAcquire::UriIterator pkgAcquire::UriEnd()
 764 {
 765    return UriIterator(0);
 766 }
 767                                                                         /*}}}*/
 768 // Acquire::MethodConfig::MethodConfig - Constructor                    /*{{{*/
 769 // ---------------------------------------------------------------------
 770 /* */
 771 pkgAcquire::MethodConfig::MethodConfig() : d(NULL), Next(0), SingleInstance(false),
 772    Pipeline(false), SendConfig(false), LocalOnly(false), NeedsCleanup(false),
 773    Removable(false)
 774 {
 775 }
 776                                                                         /*}}}*/
 777 // Queue::Queue - Constructor                                           /*{{{*/
 778 // ---------------------------------------------------------------------
 779 /* */
 780 pkgAcquire::Queue::Queue(string const &name,pkgAcquire * const owner) : d(NULL), Next(0),
 781    Name(name), Items(0), Workers(0), Owner(owner), PipeDepth(0), MaxPipeDepth(1)
 782 {
 783 }
 784                                                                         /*}}}*/
 785 // Queue::~Queue - Destructor                                           /*{{{*/
 786 // ---------------------------------------------------------------------
 787 /* */
 788 pkgAcquire::Queue::~Queue()
 789 {
 790    Shutdown(true);
 791
 792    while (Items != 0)
 793    {
 794       QItem *Jnk = Items;
 795       Items = Items->Next;
 796       delete Jnk;
 797    }
 798 }
 799                                                                         /*}}}*/
 800 // Queue::Enqueue - Queue an item to the queue                          /*{{{*/
 801 // ---------------------------------------------------------------------
 802 /* */
 803 bool pkgAcquire::Queue::Enqueue(ItemDesc &Item)
 804 {
 805    QItem **I = &Items;
 806    // move to the end of the queue and check for duplicates here
 807    HashStringList const hsl = Item.Owner->GetExpectedHashes();
 808    for (; *I != 0; I = &(*I)->Next)
 809       if (Item.URI == (*I)->URI || hsl == (*I)->Owner->GetExpectedHashes())
 810       {
 811          if (_config->FindB("Debug::pkgAcquire::Worker",false) == true)
 812             std::cerr << " @ Queue: Action combined for " << Item.URI << " and " << (*I)->URI << std::endl;
 813          (*I)->Owners.push_back(Item.Owner);
 814          Item.Owner->Status = (*I)->Owner->Status;
 815          return false;
 816       }
 817
 818    // Create a new item
 819    QItem *Itm = new QItem;
 820    *Itm = Item;
 821    Itm->Next = 0;
 822    *I = Itm;
 823
 824    Item.Owner->QueueCounter++;
 825    if (Items->Next == 0)
 826       Cycle();
 827    return true;
 828 }
 829                                                                         /*}}}*/
 830 // Queue::Dequeue - Remove an item from the queue                       /*{{{*/
 831 // ---------------------------------------------------------------------
 832 /* We return true if we hit something */
 833 bool pkgAcquire::Queue::Dequeue(Item *Owner)
 834 {
 835    if (Owner->Status == pkgAcquire::Item::StatFetching)
 836       return _error->Error("Tried to dequeue a fetching object");
 837
 838    bool Res = false;
 839
 840    QItem **I = &Items;
 841    for (; *I != 0;)
 842    {
 843       if (Owner == (*I)->Owner)
 844       {
 845          QItem *Jnk= *I;
 846          *I = (*I)->Next;
 847          Owner->QueueCounter--;
 848          delete Jnk;
 849          Res = true;
 850       }
 851       else
 852          I = &(*I)->Next;
 853    }
 854
 855    return Res;
 856 }
 857                                                                         /*}}}*/
 858 // Queue::Startup - Start the worker processes                          /*{{{*/
 859 // ---------------------------------------------------------------------
 860 /* It is possible for this to be called with a pre-existing set of
 861    workers. */
 862 bool pkgAcquire::Queue::Startup()
 863 {
 864    if (Workers == 0)
 865    {
 866       URI U(Name);
 867       pkgAcquire::MethodConfig *Cnf = Owner->GetConfig(U.Access);
 868       if (Cnf == 0)
 869          return false;
 870
 871       Workers = new Worker(this,Cnf,Owner->Log);
 872       Owner->Add(Workers);
 873       if (Workers->Start() == false)
 874          return false;
 875
 876       /* When pipelining we commit 10 items. This needs to change when we
 877          added other source retry to have cycle maintain a pipeline depth
 878          on its own. */
 879       if (Cnf->Pipeline == true)
 880          MaxPipeDepth = _config->FindI("Acquire::Max-Pipeline-Depth",10);
 881       else
 882          MaxPipeDepth = 1;
 883    }
 884
 885    return Cycle();
 886 }
 887                                                                         /*}}}*/
 888 // Queue::Shutdown - Shutdown the worker processes                      /*{{{*/
 889 // ---------------------------------------------------------------------
 890 /* If final is true then all workers are eliminated, otherwise only workers
 891    that do not need cleanup are removed */
 892 bool pkgAcquire::Queue::Shutdown(bool Final)
 893 {
 894    // Delete all of the workers
 895    pkgAcquire::Worker **Cur = &Workers;
 896    while (*Cur != 0)
 897    {
 898       pkgAcquire::Worker *Jnk = *Cur;
 899       if (Final == true || Jnk->GetConf()->NeedsCleanup == false)
 900       {
 901          *Cur = Jnk->NextQueue;
 902          Owner->Remove(Jnk);
 903          delete Jnk;
 904       }
 905       else
 906          Cur = &(*Cur)->NextQueue;
 907    }
 908
 909    return true;
 910 }
 911                                                                         /*}}}*/
 912 // Queue::FindItem - Find a URI in the item list                        /*{{{*/
 913 // ---------------------------------------------------------------------
 914 /* */
 915 pkgAcquire::Queue::QItem *pkgAcquire::Queue::FindItem(string URI,pkgAcquire::Worker *Owner)
 916 {
 917    for (QItem *I = Items; I != 0; I = I->Next)
 918       if (I->URI == URI && I->Worker == Owner)
 919          return I;
 920    return 0;
 921 }
 922                                                                         /*}}}*/
 923 // Queue::ItemDone - Item has been completed                            /*{{{*/
 924 // ---------------------------------------------------------------------
 925 /* The worker signals this which causes the item to be removed from the
 926    queue. If this is the last queue instance then it is removed from the
 927    main queue too.*/
 928 bool pkgAcquire::Queue::ItemDone(QItem *Itm)
 929 {
 930    PipeDepth--;
 931    for (QItem::owner_iterator O = Itm->Owners.begin(); O != Itm->Owners.end(); ++O)
 932    {
 933       if ((*O)->Status == pkgAcquire::Item::StatFetching)
 934          (*O)->Status = pkgAcquire::Item::StatDone;
 935    }
 936
 937    if (Itm->Owner->QueueCounter <= 1)
 938       Owner->Dequeue(Itm->Owner);
 939    else
 940    {
 941       Dequeue(Itm->Owner);
 942       Owner->Bump();
 943    }
 944
 945    return Cycle();
 946 }
 947                                                                         /*}}}*/
 948 // Queue::Cycle - Queue new items into the method                       /*{{{*/
 949 // ---------------------------------------------------------------------
 950 /* This locates a new idle item and sends it to the worker. If pipelining
 951    is enabled then it keeps the pipe full. */
 952 bool pkgAcquire::Queue::Cycle()
 953 {
 954    if (Items == 0 || Workers == 0)
 955       return true;
 956
 957    if (PipeDepth < 0)
 958       return _error->Error("Pipedepth failure");
 959
 960    // Look for a queable item
 961    QItem *I = Items;
 962    while (PipeDepth < (signed)MaxPipeDepth)
 963    {
 964       for (; I != 0; I = I->Next)
 965          if (I->Owner->Status == pkgAcquire::Item::StatIdle)
 966             break;
 967
 968       // Nothing to do, queue is idle.
 969       if (I == 0)
 970          return true;
 971
 972       I->Worker = Workers;
 973       for (auto const &O: I->Owners)
 974          O->Status = pkgAcquire::Item::StatFetching;
 975       PipeDepth++;
 976       if (Workers->QueueItem(I) == false)
 977          return false;
 978    }
 979
 980    return true;
 981 }
 982                                                                         /*}}}*/
 983 // Queue::Bump - Fetch any pending objects if we are idle               /*{{{*/
 984 // ---------------------------------------------------------------------
 985 /* This is called when an item in multiple queues is dequeued */
 986 void pkgAcquire::Queue::Bump()
 987 {
 988    Cycle();
 989 }
 990                                                                         /*}}}*/
 991 HashStringList pkgAcquire::Queue::QItem::GetExpectedHashes() const      /*{{{*/
 992 {
 993    /* each Item can have multiple owners and each owner might have different
 994       hashes, even if that is unlikely in practice and if so at least some
 995       owners will later fail. There is one situation through which is not a
 996       failure and still needs this handling: Two owners who expect the same
 997       file, but one owner only knows the SHA1 while the other only knows SHA256. */
 998    HashStringList superhsl;
 999    for (pkgAcquire::Queue::QItem::owner_iterator O = Owners.begin(); O != Owners.end(); ++O)
1000    {
1001       HashStringList const hsl = (*O)->GetExpectedHashes();
1002       if (hsl.usable() == false)
1003          continue;
1004       if (superhsl.usable() == false)
1005          superhsl = hsl;
1006       else
1007       {
1008          // we merge both lists - if we find disagreement send no hashes
1009          HashStringList::const_iterator hs = hsl.begin();
1010          for (; hs != hsl.end(); ++hs)
1011             if (superhsl.push_back(*hs) == false)
1012                break;
1013          if (hs != hsl.end())
1014          {
1015             superhsl.clear();
1016             break;
1017          }
1018       }
1019    }
1020    return superhsl;
1021 }
1022                                                                         /*}}}*/
1023 APT_PURE unsigned long long pkgAcquire::Queue::QItem::GetMaximumSize() const    /*{{{*/
1024 {
1025    unsigned long long Maximum = std::numeric_limits<unsigned long long>::max();
1026    for (auto const &O: Owners)
1027    {
1028       if (O->FileSize == 0)
1029          continue;
1030       Maximum = std::min(Maximum, O->FileSize);
1031    }
1032    if (Maximum == std::numeric_limits<unsigned long long>::max())
1033       return 0;
1034    return Maximum;
1035 }
1036                                                                         /*}}}*/
1037 void pkgAcquire::Queue::QItem::SyncDestinationFiles() const             /*{{{*/
1038 {
1039    /* ensure that the first owner has the best partial file of all and
1040       the rest have (potentially dangling) symlinks to it so that
1041       everything (like progress reporting) finds it easily */
1042    std::string superfile = Owner->DestFile;
1043    off_t supersize = 0;
1044    for (pkgAcquire::Queue::QItem::owner_iterator O = Owners.begin(); O != Owners.end(); ++O)
1045    {
1046       if ((*O)->DestFile == superfile)
1047          continue;
1048       struct stat file;
1049       if (lstat((*O)->DestFile.c_str(),&file) == 0)
1050       {
1051          if ((file.st_mode & S_IFREG) == 0)
1052             RemoveFile("SyncDestinationFiles", (*O)->DestFile);
1053          else if (supersize < file.st_size)
1054          {
1055             supersize = file.st_size;
1056             RemoveFile("SyncDestinationFiles", superfile);
1057             rename((*O)->DestFile.c_str(), superfile.c_str());
1058          }
1059          else
1060             RemoveFile("SyncDestinationFiles", (*O)->DestFile);
1061          if (symlink(superfile.c_str(), (*O)->DestFile.c_str()) != 0)
1062          {
1063             ; // not a problem per-se and no real alternative
1064          }
1065       }
1066    }
1067 }
1068                                                                         /*}}}*/
1069 std::string pkgAcquire::Queue::QItem::Custom600Headers() const          /*{{{*/
1070 {
1071    /* The others are relatively easy to merge, but this one?
1072       Lets not merge and see how far we can run with it…
1073       Likely, nobody will ever notice as all the items will
1074       be of the same class and hence generate the same headers. */
1075    return Owner->Custom600Headers();
1076 }
1077                                                                         /*}}}*/
1078
1079 // AcquireStatus::pkgAcquireStatus - Constructor                        /*{{{*/
1080 // ---------------------------------------------------------------------
1081 /* */
1082 pkgAcquireStatus::pkgAcquireStatus() : d(NULL), Percent(-1), Update(true), MorePulses(false)
1083 {
1084    Start();
1085 }
1086                                                                         /*}}}*/
1087 // AcquireStatus::Pulse - Called periodically                           /*{{{*/
1088 // ---------------------------------------------------------------------
1089 /* This computes some internal state variables for the derived classes to
1090    use. It generates the current downloaded bytes and total bytes to download
1091    as well as the current CPS estimate. */
1092 bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
1093 {
1094    TotalBytes = 0;
1095    CurrentBytes = 0;
1096    TotalItems = 0;
1097    CurrentItems = 0;
1098
1099    // Compute the total number of bytes to fetch
1100    unsigned int Unknown = 0;
1101    unsigned int Count = 0;
1102    bool UnfetchedReleaseFiles = false;
1103    for (pkgAcquire::ItemCIterator I = Owner->ItemsBegin();
1104         I != Owner->ItemsEnd();
1105         ++I, ++Count)
1106    {
1107       TotalItems++;
1108       if ((*I)->Status == pkgAcquire::Item::StatDone)
1109          ++CurrentItems;
1110
1111       // Totally ignore local items
1112       if ((*I)->Local == true)
1113          continue;
1114
1115       // see if the method tells us to expect more
1116       TotalItems += (*I)->ExpectedAdditionalItems;
1117
1118       // check if there are unfetched Release files
1119       if ((*I)->Complete == false && (*I)->ExpectedAdditionalItems > 0)
1120          UnfetchedReleaseFiles = true;
1121
1122       TotalBytes += (*I)->FileSize;
1123       if ((*I)->Complete == true)
1124          CurrentBytes += (*I)->FileSize;
1125       if ((*I)->FileSize == 0 && (*I)->Complete == false)
1126          ++Unknown;
1127    }
1128
1129    // Compute the current completion
1130    unsigned long long ResumeSize = 0;
1131    for (pkgAcquire::Worker *I = Owner->WorkersBegin(); I != 0;
1132         I = Owner->WorkerStep(I))
1133    {
1134       if (I->CurrentItem != 0 && I->CurrentItem->Owner->Complete == false)
1135       {
1136          CurrentBytes += I->CurrentSize;
1137          ResumeSize += I->ResumePoint;
1138
1139          // Files with unknown size always have 100% completion
1140          if (I->CurrentItem->Owner->FileSize == 0 &&
1141              I->CurrentItem->Owner->Complete == false)
1142             TotalBytes += I->CurrentSize;
1143       }
1144    }
1145
1146    // Normalize the figures and account for unknown size downloads
1147    if (TotalBytes <= 0)
1148       TotalBytes = 1;
1149    if (Unknown == Count)
1150       TotalBytes = Unknown;
1151
1152    // Wha?! Is not supposed to happen.
1153    if (CurrentBytes > TotalBytes)
1154       CurrentBytes = TotalBytes;
1155
1156    // debug
1157    if (_config->FindB("Debug::acquire::progress", false) == true)
1158       std::clog << " Bytes: "
1159                 << SizeToStr(CurrentBytes) << " / " << SizeToStr(TotalBytes)
1160                 << std::endl;
1161
1162    // Compute the CPS
1163    struct timeval NewTime;
1164    gettimeofday(&NewTime,0);
1165    if ((NewTime.tv_sec - Time.tv_sec == 6 && NewTime.tv_usec > Time.tv_usec) ||
1166        NewTime.tv_sec - Time.tv_sec > 6)
1167    {
1168       double Delta = NewTime.tv_sec - Time.tv_sec +
1169                      (NewTime.tv_usec - Time.tv_usec)/1000000.0;
1170
1171       // Compute the CPS value
1172       if (Delta < 0.01)
1173          CurrentCPS = 0;
1174       else
1175          CurrentCPS = ((CurrentBytes - ResumeSize) - LastBytes)/Delta;
1176       LastBytes = CurrentBytes - ResumeSize;
1177       ElapsedTime = (unsigned long long)Delta;
1178       Time = NewTime;
1179    }
1180
1181    double const OldPercent = Percent;
1182    // calculate the percentage, if we have too little data assume 1%
1183    if (TotalBytes > 0 && UnfetchedReleaseFiles)
1184       Percent = 0;
1185    else
1186       // use both files and bytes because bytes can be unreliable
1187       Percent = (0.8 * (CurrentBytes/float(TotalBytes)*100.0) +
1188                  0.2 * (CurrentItems/float(TotalItems)*100.0));
1189    double const DiffPercent = Percent - OldPercent;
1190    if (DiffPercent < 0.001 && _config->FindB("Acquire::Progress::Diffpercent", false) == true)
1191       return true;
1192
1193    int fd = _config->FindI("APT::Status-Fd",-1);
1194    if(fd > 0)
1195    {
1196       ostringstream status;
1197
1198       char msg[200];
1199       long i = CurrentItems < TotalItems ? CurrentItems + 1 : CurrentItems;
1200       unsigned long long ETA = 0;
1201       if(CurrentCPS > 0)
1202          ETA = (TotalBytes - CurrentBytes) / CurrentCPS;
1203
1204       // only show the ETA if it makes sense
1205       if (ETA > 0 && ETA < 172800 /* two days */ )
1206          snprintf(msg,sizeof(msg), _("Retrieving file %li of %li (%s remaining)"), i, TotalItems, TimeToStr(ETA).c_str());
1207       else
1208          snprintf(msg,sizeof(msg), _("Retrieving file %li of %li"), i, TotalItems);
1209
1210       // build the status str
1211       status << "dlstatus:" << i
1212              << ":"  << std::setprecision(3) << Percent
1213              << ":" << msg
1214              << endl;
1215
1216       std::string const dlstatus = status.str();
1217       FileFd::Write(fd, dlstatus.c_str(), dlstatus.size());
1218    }
1219
1220    return true;
1221 }
1222                                                                         /*}}}*/
1223 // AcquireStatus::Start - Called when the download is started           /*{{{*/
1224 // ---------------------------------------------------------------------
1225 /* We just reset the counters */
1226 void pkgAcquireStatus::Start()
1227 {
1228    gettimeofday(&Time,0);
1229    gettimeofday(&StartTime,0);
1230    LastBytes = 0;
1231    CurrentCPS = 0;
1232    CurrentBytes = 0;
1233    TotalBytes = 0;
1234    FetchedBytes = 0;
1235    ElapsedTime = 0;
1236    TotalItems = 0;
1237    CurrentItems = 0;
1238 }
1239                                                                         /*}}}*/
1240 // AcquireStatus::Stop - Finished downloading                           /*{{{*/
1241 // ---------------------------------------------------------------------
1242 /* This accurately computes the elapsed time and the total overall CPS. */
1243 void pkgAcquireStatus::Stop()
1244 {
1245    // Compute the CPS and elapsed time
1246    struct timeval NewTime;
1247    gettimeofday(&NewTime,0);
1248
1249    double Delta = NewTime.tv_sec - StartTime.tv_sec +
1250                   (NewTime.tv_usec - StartTime.tv_usec)/1000000.0;
1251
1252    // Compute the CPS value
1253    if (Delta < 0.01)
1254       CurrentCPS = 0;
1255    else
1256       CurrentCPS = FetchedBytes/Delta;
1257    LastBytes = CurrentBytes;
1258    ElapsedTime = (unsigned long long)Delta;
1259 }
1260                                                                         /*}}}*/
1261 // AcquireStatus::Fetched - Called when a byte set has been fetched     /*{{{*/
1262 // ---------------------------------------------------------------------
1263 /* This is used to get accurate final transfer rate reporting. */
1264 void pkgAcquireStatus::Fetched(unsigned long long Size,unsigned long long Resume)
1265 {
1266    FetchedBytes += Size - Resume;
1267 }
1268                                                                         /*}}}*/
1269
1270 pkgAcquire::UriIterator::UriIterator(pkgAcquire::Queue *Q) : d(NULL), CurQ(Q), CurItem(0)
1271 {
1272    while (CurItem == 0 && CurQ != 0)
1273    {
1274       CurItem = CurQ->Items;
1275       CurQ = CurQ->Next;
1276    }
1277 }
1278
1279 APT_CONST pkgAcquire::UriIterator::~UriIterator() {}
1280 APT_CONST pkgAcquire::MethodConfig::~MethodConfig() {}
1281 APT_CONST pkgAcquireStatus::~pkgAcquireStatus() {}