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,".") == 0 ||
 692           strcmp(Dir->d_name,"..") == 0)
 693          continue;
 694
 695       // Look in the get list
 696       ItemCIterator I = Items.begin();
 697       for (; I != Items.end(); ++I)
 698          if (flNotDir((*I)->DestFile) == Dir->d_name)
 699             break;
 700
 701       // Nothing found, nuke it
 702       if (I == Items.end())
 703          RemoveFile("Clean", Dir->d_name);
 704    };
 705
 706    closedir(D);
 707    if (chdir(StartDir.c_str()) != 0)
 708       return _error->Errno("chdir",_("Unable to change to %s"),StartDir.c_str());
 709    return true;
 710 }
 711                                                                         /*}}}*/
 712 // Acquire::TotalNeeded - Number of bytes to fetch                      /*{{{*/
 713 // ---------------------------------------------------------------------
 714 /* This is the total number of bytes needed */
 715 APT_PURE unsigned long long pkgAcquire::TotalNeeded()
 716 {
 717    return std::accumulate(ItemsBegin(), ItemsEnd(), 0,
 718       [](unsigned long long const T, Item const * const I) {
 719          return T + I->FileSize;
 720    });
 721 }
 722                                                                         /*}}}*/
 723 // Acquire::FetchNeeded - Number of bytes needed to get                 /*{{{*/
 724 // ---------------------------------------------------------------------
 725 /* This is the number of bytes that is not local */
 726 APT_PURE unsigned long long pkgAcquire::FetchNeeded()
 727 {
 728    return std::accumulate(ItemsBegin(), ItemsEnd(), 0,
 729       [](unsigned long long const T, Item const * const I) {
 730          if (I->Local == false)
 731             return T + I->FileSize;
 732          else
 733             return T;
 734    });
 735 }
 736                                                                         /*}}}*/
 737 // Acquire::PartialPresent - Number of partial bytes we already have    /*{{{*/
 738 // ---------------------------------------------------------------------
 739 /* This is the number of bytes that is not local */
 740 APT_PURE unsigned long long pkgAcquire::PartialPresent()
 741 {
 742    return std::accumulate(ItemsBegin(), ItemsEnd(), 0,
 743       [](unsigned long long const T, Item const * const I) {
 744          if (I->Local == false)
 745             return T + I->PartialSize;
 746          else
 747             return T;
 748    });
 749 }
 750                                                                         /*}}}*/
 751 // Acquire::UriBegin - Start iterator for the uri list                  /*{{{*/
 752 // ---------------------------------------------------------------------
 753 /* */
 754 pkgAcquire::UriIterator pkgAcquire::UriBegin()
 755 {
 756    return UriIterator(Queues);
 757 }
 758                                                                         /*}}}*/
 759 // Acquire::UriEnd - End iterator for the uri list                      /*{{{*/
 760 // ---------------------------------------------------------------------
 761 /* */
 762 pkgAcquire::UriIterator pkgAcquire::UriEnd()
 763 {
 764    return UriIterator(0);
 765 }
 766                                                                         /*}}}*/
 767 // Acquire::MethodConfig::MethodConfig - Constructor                    /*{{{*/
 768 // ---------------------------------------------------------------------
 769 /* */
 770 pkgAcquire::MethodConfig::MethodConfig() : d(NULL), Next(0), SingleInstance(false),
 771    Pipeline(false), SendConfig(false), LocalOnly(false), NeedsCleanup(false),
 772    Removable(false)
 773 {
 774 }
 775                                                                         /*}}}*/
 776 // Queue::Queue - Constructor                                           /*{{{*/
 777 // ---------------------------------------------------------------------
 778 /* */
 779 pkgAcquire::Queue::Queue(string const &name,pkgAcquire * const owner) : d(NULL), Next(0),
 780    Name(name), Items(0), Workers(0), Owner(owner), PipeDepth(0), MaxPipeDepth(1)
 781 {
 782 }
 783                                                                         /*}}}*/
 784 // Queue::~Queue - Destructor                                           /*{{{*/
 785 // ---------------------------------------------------------------------
 786 /* */
 787 pkgAcquire::Queue::~Queue()
 788 {
 789    Shutdown(true);
 790
 791    while (Items != 0)
 792    {
 793       QItem *Jnk = Items;
 794       Items = Items->Next;
 795       delete Jnk;
 796    }
 797 }
 798                                                                         /*}}}*/
 799 // Queue::Enqueue - Queue an item to the queue                          /*{{{*/
 800 // ---------------------------------------------------------------------
 801 /* */
 802 bool pkgAcquire::Queue::Enqueue(ItemDesc &Item)
 803 {
 804    QItem **I = &Items;
 805    // move to the end of the queue and check for duplicates here
 806    HashStringList const hsl = Item.Owner->GetExpectedHashes();
 807    for (; *I != 0; I = &(*I)->Next)
 808       if (Item.URI == (*I)->URI || hsl == (*I)->Owner->GetExpectedHashes())
 809       {
 810          if (_config->FindB("Debug::pkgAcquire::Worker",false) == true)
 811             std::cerr << " @ Queue: Action combined for " << Item.URI << " and " << (*I)->URI << std::endl;
 812          (*I)->Owners.push_back(Item.Owner);
 813          Item.Owner->Status = (*I)->Owner->Status;
 814          return false;
 815       }
 816
 817    // Create a new item
 818    QItem *Itm = new QItem;
 819    *Itm = Item;
 820    Itm->Next = 0;
 821    *I = Itm;
 822
 823    Item.Owner->QueueCounter++;
 824    if (Items->Next == 0)
 825       Cycle();
 826    return true;
 827 }
 828                                                                         /*}}}*/
 829 // Queue::Dequeue - Remove an item from the queue                       /*{{{*/
 830 // ---------------------------------------------------------------------
 831 /* We return true if we hit something */
 832 bool pkgAcquire::Queue::Dequeue(Item *Owner)
 833 {
 834    if (Owner->Status == pkgAcquire::Item::StatFetching)
 835       return _error->Error("Tried to dequeue a fetching object");
 836
 837    bool Res = false;
 838
 839    QItem **I = &Items;
 840    for (; *I != 0;)
 841    {
 842       if (Owner == (*I)->Owner)
 843       {
 844          QItem *Jnk= *I;
 845          *I = (*I)->Next;
 846          Owner->QueueCounter--;
 847          delete Jnk;
 848          Res = true;
 849       }
 850       else
 851          I = &(*I)->Next;
 852    }
 853
 854    return Res;
 855 }
 856                                                                         /*}}}*/
 857 // Queue::Startup - Start the worker processes                          /*{{{*/
 858 // ---------------------------------------------------------------------
 859 /* It is possible for this to be called with a pre-existing set of
 860    workers. */
 861 bool pkgAcquire::Queue::Startup()
 862 {
 863    if (Workers == 0)
 864    {
 865       URI U(Name);
 866       pkgAcquire::MethodConfig *Cnf = Owner->GetConfig(U.Access);
 867       if (Cnf == 0)
 868          return false;
 869
 870       Workers = new Worker(this,Cnf,Owner->Log);
 871       Owner->Add(Workers);
 872       if (Workers->Start() == false)
 873          return false;
 874
 875       /* When pipelining we commit 10 items. This needs to change when we
 876          added other source retry to have cycle maintain a pipeline depth
 877          on its own. */
 878       if (Cnf->Pipeline == true)
 879          MaxPipeDepth = _config->FindI("Acquire::Max-Pipeline-Depth",10);
 880       else
 881          MaxPipeDepth = 1;
 882    }
 883
 884    return Cycle();
 885 }
 886                                                                         /*}}}*/
 887 // Queue::Shutdown - Shutdown the worker processes                      /*{{{*/
 888 // ---------------------------------------------------------------------
 889 /* If final is true then all workers are eliminated, otherwise only workers
 890    that do not need cleanup are removed */
 891 bool pkgAcquire::Queue::Shutdown(bool Final)
 892 {
 893    // Delete all of the workers
 894    pkgAcquire::Worker **Cur = &Workers;
 895    while (*Cur != 0)
 896    {
 897       pkgAcquire::Worker *Jnk = *Cur;
 898       if (Final == true || Jnk->GetConf()->NeedsCleanup == false)
 899       {
 900          *Cur = Jnk->NextQueue;
 901          Owner->Remove(Jnk);
 902          delete Jnk;
 903       }
 904       else
 905          Cur = &(*Cur)->NextQueue;
 906    }
 907
 908    return true;
 909 }
 910                                                                         /*}}}*/
 911 // Queue::FindItem - Find a URI in the item list                        /*{{{*/
 912 // ---------------------------------------------------------------------
 913 /* */
 914 pkgAcquire::Queue::QItem *pkgAcquire::Queue::FindItem(string URI,pkgAcquire::Worker *Owner)
 915 {
 916    for (QItem *I = Items; I != 0; I = I->Next)
 917       if (I->URI == URI && I->Worker == Owner)
 918          return I;
 919    return 0;
 920 }
 921                                                                         /*}}}*/
 922 // Queue::ItemDone - Item has been completed                            /*{{{*/
 923 // ---------------------------------------------------------------------
 924 /* The worker signals this which causes the item to be removed from the
 925    queue. If this is the last queue instance then it is removed from the
 926    main queue too.*/
 927 bool pkgAcquire::Queue::ItemDone(QItem *Itm)
 928 {
 929    PipeDepth--;
 930    for (QItem::owner_iterator O = Itm->Owners.begin(); O != Itm->Owners.end(); ++O)
 931    {
 932       if ((*O)->Status == pkgAcquire::Item::StatFetching)
 933          (*O)->Status = pkgAcquire::Item::StatDone;
 934    }
 935
 936    if (Itm->Owner->QueueCounter <= 1)
 937       Owner->Dequeue(Itm->Owner);
 938    else
 939    {
 940       Dequeue(Itm->Owner);
 941       Owner->Bump();
 942    }
 943
 944    return Cycle();
 945 }
 946                                                                         /*}}}*/
 947 // Queue::Cycle - Queue new items into the method                       /*{{{*/
 948 // ---------------------------------------------------------------------
 949 /* This locates a new idle item and sends it to the worker. If pipelining
 950    is enabled then it keeps the pipe full. */
 951 bool pkgAcquire::Queue::Cycle()
 952 {
 953    if (Items == 0 || Workers == 0)
 954       return true;
 955
 956    if (PipeDepth < 0)
 957       return _error->Error("Pipedepth failure");
 958
 959    // Look for a queable item
 960    QItem *I = Items;
 961    while (PipeDepth < (signed)MaxPipeDepth)
 962    {
 963       for (; I != 0; I = I->Next)
 964          if (I->Owner->Status == pkgAcquire::Item::StatIdle)
 965             break;
 966
 967       // Nothing to do, queue is idle.
 968       if (I == 0)
 969          return true;
 970
 971       I->Worker = Workers;
 972       for (auto const &O: I->Owners)
 973          O->Status = pkgAcquire::Item::StatFetching;
 974       PipeDepth++;
 975       if (Workers->QueueItem(I) == false)
 976          return false;
 977    }
 978
 979    return true;
 980 }
 981                                                                         /*}}}*/
 982 // Queue::Bump - Fetch any pending objects if we are idle               /*{{{*/
 983 // ---------------------------------------------------------------------
 984 /* This is called when an item in multiple queues is dequeued */
 985 void pkgAcquire::Queue::Bump()
 986 {
 987    Cycle();
 988 }
 989                                                                         /*}}}*/
 990 HashStringList pkgAcquire::Queue::QItem::GetExpectedHashes() const      /*{{{*/
 991 {
 992    /* each Item can have multiple owners and each owner might have different
 993       hashes, even if that is unlikely in practice and if so at least some
 994       owners will later fail. There is one situation through which is not a
 995       failure and still needs this handling: Two owners who expect the same
 996       file, but one owner only knows the SHA1 while the other only knows SHA256. */
 997    HashStringList superhsl;
 998    for (pkgAcquire::Queue::QItem::owner_iterator O = Owners.begin(); O != Owners.end(); ++O)
 999    {
1000       HashStringList const hsl = (*O)->GetExpectedHashes();
1001       if (hsl.usable() == false)
1002          continue;
1003       if (superhsl.usable() == false)
1004          superhsl = hsl;
1005       else
1006       {
1007          // we merge both lists - if we find disagreement send no hashes
1008          HashStringList::const_iterator hs = hsl.begin();
1009          for (; hs != hsl.end(); ++hs)
1010             if (superhsl.push_back(*hs) == false)
1011                break;
1012          if (hs != hsl.end())
1013          {
1014             superhsl.clear();
1015             break;
1016          }
1017       }
1018    }
1019    return superhsl;
1020 }
1021                                                                         /*}}}*/
1022 APT_PURE unsigned long long pkgAcquire::Queue::QItem::GetMaximumSize() const    /*{{{*/
1023 {
1024    unsigned long long Maximum = std::numeric_limits<unsigned long long>::max();
1025    for (auto const &O: Owners)
1026    {
1027       if (O->FileSize == 0)
1028          continue;
1029       Maximum = std::min(Maximum, O->FileSize);
1030    }
1031    if (Maximum == std::numeric_limits<unsigned long long>::max())
1032       return 0;
1033    return Maximum;
1034 }
1035                                                                         /*}}}*/
1036 void pkgAcquire::Queue::QItem::SyncDestinationFiles() const             /*{{{*/
1037 {
1038    /* ensure that the first owner has the best partial file of all and
1039       the rest have (potentially dangling) symlinks to it so that
1040       everything (like progress reporting) finds it easily */
1041    std::string superfile = Owner->DestFile;
1042    off_t supersize = 0;
1043    for (pkgAcquire::Queue::QItem::owner_iterator O = Owners.begin(); O != Owners.end(); ++O)
1044    {
1045       if ((*O)->DestFile == superfile)
1046          continue;
1047       struct stat file;
1048       if (lstat((*O)->DestFile.c_str(),&file) == 0)
1049       {
1050          if ((file.st_mode & S_IFREG) == 0)
1051             RemoveFile("SyncDestinationFiles", (*O)->DestFile);
1052          else if (supersize < file.st_size)
1053          {
1054             supersize = file.st_size;
1055             RemoveFile("SyncDestinationFiles", superfile);
1056             rename((*O)->DestFile.c_str(), superfile.c_str());
1057          }
1058          else
1059             RemoveFile("SyncDestinationFiles", (*O)->DestFile);
1060          if (symlink(superfile.c_str(), (*O)->DestFile.c_str()) != 0)
1061          {
1062             ; // not a problem per-se and no real alternative
1063          }
1064       }
1065    }
1066 }
1067                                                                         /*}}}*/
1068 std::string pkgAcquire::Queue::QItem::Custom600Headers() const          /*{{{*/
1069 {
1070    /* The others are relatively easy to merge, but this one?
1071       Lets not merge and see how far we can run with it…
1072       Likely, nobody will ever notice as all the items will
1073       be of the same class and hence generate the same headers. */
1074    return Owner->Custom600Headers();
1075 }
1076                                                                         /*}}}*/
1077
1078 // AcquireStatus::pkgAcquireStatus - Constructor                        /*{{{*/
1079 // ---------------------------------------------------------------------
1080 /* */
1081 pkgAcquireStatus::pkgAcquireStatus() : d(NULL), Percent(-1), Update(true), MorePulses(false)
1082 {
1083    Start();
1084 }
1085                                                                         /*}}}*/
1086 // AcquireStatus::Pulse - Called periodically                           /*{{{*/
1087 // ---------------------------------------------------------------------
1088 /* This computes some internal state variables for the derived classes to
1089    use. It generates the current downloaded bytes and total bytes to download
1090    as well as the current CPS estimate. */
1091 bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
1092 {
1093    TotalBytes = 0;
1094    CurrentBytes = 0;
1095    TotalItems = 0;
1096    CurrentItems = 0;
1097
1098    // Compute the total number of bytes to fetch
1099    unsigned int Unknown = 0;
1100    unsigned int Count = 0;
1101    bool UnfetchedReleaseFiles = false;
1102    for (pkgAcquire::ItemCIterator I = Owner->ItemsBegin();
1103         I != Owner->ItemsEnd();
1104         ++I, ++Count)
1105    {
1106       TotalItems++;
1107       if ((*I)->Status == pkgAcquire::Item::StatDone)
1108          ++CurrentItems;
1109
1110       // Totally ignore local items
1111       if ((*I)->Local == true)
1112          continue;
1113
1114       // see if the method tells us to expect more
1115       TotalItems += (*I)->ExpectedAdditionalItems;
1116
1117       // check if there are unfetched Release files
1118       if ((*I)->Complete == false && (*I)->ExpectedAdditionalItems > 0)
1119          UnfetchedReleaseFiles = true;
1120
1121       TotalBytes += (*I)->FileSize;
1122       if ((*I)->Complete == true)
1123          CurrentBytes += (*I)->FileSize;
1124       if ((*I)->FileSize == 0 && (*I)->Complete == false)
1125          ++Unknown;
1126    }
1127
1128    // Compute the current completion
1129    unsigned long long ResumeSize = 0;
1130    for (pkgAcquire::Worker *I = Owner->WorkersBegin(); I != 0;
1131         I = Owner->WorkerStep(I))
1132    {
1133       if (I->CurrentItem != 0 && I->CurrentItem->Owner->Complete == false)
1134       {
1135          CurrentBytes += I->CurrentSize;
1136          ResumeSize += I->ResumePoint;
1137
1138          // Files with unknown size always have 100% completion
1139          if (I->CurrentItem->Owner->FileSize == 0 &&
1140              I->CurrentItem->Owner->Complete == false)
1141             TotalBytes += I->CurrentSize;
1142       }
1143    }
1144
1145    // Normalize the figures and account for unknown size downloads
1146    if (TotalBytes <= 0)
1147       TotalBytes = 1;
1148    if (Unknown == Count)
1149       TotalBytes = Unknown;
1150
1151    // Wha?! Is not supposed to happen.
1152    if (CurrentBytes > TotalBytes)
1153       CurrentBytes = TotalBytes;
1154
1155    // debug
1156    if (_config->FindB("Debug::acquire::progress", false) == true)
1157       std::clog << " Bytes: "
1158                 << SizeToStr(CurrentBytes) << " / " << SizeToStr(TotalBytes)
1159                 << std::endl;
1160
1161    // Compute the CPS
1162    struct timeval NewTime;
1163    gettimeofday(&NewTime,0);
1164    if ((NewTime.tv_sec - Time.tv_sec == 6 && NewTime.tv_usec > Time.tv_usec) ||
1165        NewTime.tv_sec - Time.tv_sec > 6)
1166    {
1167       double Delta = NewTime.tv_sec - Time.tv_sec +
1168                      (NewTime.tv_usec - Time.tv_usec)/1000000.0;
1169
1170       // Compute the CPS value
1171       if (Delta < 0.01)
1172          CurrentCPS = 0;
1173       else
1174          CurrentCPS = ((CurrentBytes - ResumeSize) - LastBytes)/Delta;
1175       LastBytes = CurrentBytes - ResumeSize;
1176       ElapsedTime = (unsigned long long)Delta;
1177       Time = NewTime;
1178    }
1179
1180    double const OldPercent = Percent;
1181    // calculate the percentage, if we have too little data assume 1%
1182    if (TotalBytes > 0 && UnfetchedReleaseFiles)
1183       Percent = 0;
1184    else
1185       // use both files and bytes because bytes can be unreliable
1186       Percent = (0.8 * (CurrentBytes/float(TotalBytes)*100.0) +
1187                  0.2 * (CurrentItems/float(TotalItems)*100.0));
1188    double const DiffPercent = Percent - OldPercent;
1189    if (DiffPercent < 0.001 && _config->FindB("Acquire::Progress::Diffpercent", false) == true)
1190       return true;
1191
1192    int fd = _config->FindI("APT::Status-Fd",-1);
1193    if(fd > 0)
1194    {
1195       ostringstream status;
1196
1197       char msg[200];
1198       long i = CurrentItems < TotalItems ? CurrentItems + 1 : CurrentItems;
1199       unsigned long long ETA = 0;
1200       if(CurrentCPS > 0)
1201          ETA = (TotalBytes - CurrentBytes) / CurrentCPS;
1202
1203       // only show the ETA if it makes sense
1204       if (ETA > 0 && ETA < 172800 /* two days */ )
1205          snprintf(msg,sizeof(msg), _("Retrieving file %li of %li (%s remaining)"), i, TotalItems, TimeToStr(ETA).c_str());
1206       else
1207          snprintf(msg,sizeof(msg), _("Retrieving file %li of %li"), i, TotalItems);
1208
1209       // build the status str
1210       status << "dlstatus:" << i
1211              << ":"  << std::setprecision(3) << Percent
1212              << ":" << msg
1213              << endl;
1214
1215       std::string const dlstatus = status.str();
1216       FileFd::Write(fd, dlstatus.c_str(), dlstatus.size());
1217    }
1218
1219    return true;
1220 }
1221                                                                         /*}}}*/
1222 // AcquireStatus::Start - Called when the download is started           /*{{{*/
1223 // ---------------------------------------------------------------------
1224 /* We just reset the counters */
1225 void pkgAcquireStatus::Start()
1226 {
1227    gettimeofday(&Time,0);
1228    gettimeofday(&StartTime,0);
1229    LastBytes = 0;
1230    CurrentCPS = 0;
1231    CurrentBytes = 0;
1232    TotalBytes = 0;
1233    FetchedBytes = 0;
1234    ElapsedTime = 0;
1235    TotalItems = 0;
1236    CurrentItems = 0;
1237 }
1238                                                                         /*}}}*/
1239 // AcquireStatus::Stop - Finished downloading                           /*{{{*/
1240 // ---------------------------------------------------------------------
1241 /* This accurately computes the elapsed time and the total overall CPS. */
1242 void pkgAcquireStatus::Stop()
1243 {
1244    // Compute the CPS and elapsed time
1245    struct timeval NewTime;
1246    gettimeofday(&NewTime,0);
1247
1248    double Delta = NewTime.tv_sec - StartTime.tv_sec +
1249                   (NewTime.tv_usec - StartTime.tv_usec)/1000000.0;
1250
1251    // Compute the CPS value
1252    if (Delta < 0.01)
1253       CurrentCPS = 0;
1254    else
1255       CurrentCPS = FetchedBytes/Delta;
1256    LastBytes = CurrentBytes;
1257    ElapsedTime = (unsigned long long)Delta;
1258 }
1259                                                                         /*}}}*/
1260 // AcquireStatus::Fetched - Called when a byte set has been fetched     /*{{{*/
1261 // ---------------------------------------------------------------------
1262 /* This is used to get accurate final transfer rate reporting. */
1263 void pkgAcquireStatus::Fetched(unsigned long long Size,unsigned long long Resume)
1264 {
1265    FetchedBytes += Size - Resume;
1266 }
1267                                                                         /*}}}*/
1268
1269 pkgAcquire::UriIterator::UriIterator(pkgAcquire::Queue *Q) : d(NULL), CurQ(Q), CurItem(0)
1270 {
1271    while (CurItem == 0 && CurQ != 0)
1272    {
1273       CurItem = CurQ->Items;
1274       CurQ = CurQ->Next;
1275    }
1276 }
1277
1278 APT_CONST pkgAcquire::UriIterator::~UriIterator() {}
1279 APT_CONST pkgAcquire::MethodConfig::~MethodConfig() {}
1280 APT_CONST pkgAcquireStatus::~pkgAcquireStatus() {}