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         string FullQueueName;
 356
 357    if (U.Host.empty())
 358    {
 359       long randomQueue = random();
 360 #ifdef _SC_NPROCESSORS_ONLN
 361       long cpuCount = sysconf(_SC_NPROCESSORS_ONLN) * 2;
 362 #else
 363       long cpuCount = _config->FindI("Acquire::QueueHost::Limit",10);
 364 #endif
 365       if (cpuCount > 0)
 366          randomQueue %= cpuCount;
 367
 368       strprintf(FullQueueName, "%s%ld", AccessSchema.c_str(), randomQueue);
 369       if (Debug) {
 370          clog << "Chose random queue " << FullQueueName << " for " << Uri << endl;
 371       }
 372    } else
 373    {
 374       FullQueueName = AccessSchema + U.Host;
 375    }
 376    unsigned int Instances = 0, SchemaLength = AccessSchema.length();
 377
 378    Queue *I = Queues;
 379    for (; I != 0; I = I->Next) {
 380       // if the queue already exists, re-use it
 381       if (I->Name == FullQueueName)
 382          return FullQueueName;
 383
 384       if (I->Name.compare(0, SchemaLength, AccessSchema) == 0)
 385          Instances++;
 386    }
 387
 388    if (Debug) {
 389       clog << "Found " << Instances << " instances of " << U.Access << endl;
 390    }
 391
 392    if (Instances >= (unsigned int)_config->FindI("Acquire::QueueHost::Limit",10))
 393       return U.Access;
 394
 395    return FullQueueName;
 396 }
 397                                                                         /*}}}*/
 398 // Acquire::GetConfig - Fetch the configuration information             /*{{{*/
 399 // ---------------------------------------------------------------------
 400 /* This locates the configuration structure for an access method. If
 401    a config structure cannot be found a Worker will be created to
 402    retrieve it */
 403 pkgAcquire::MethodConfig *pkgAcquire::GetConfig(string Access)
 404 {
 405    // Search for an existing config
 406    MethodConfig *Conf;
 407    for (Conf = Configs; Conf != 0; Conf = Conf->Next)
 408       if (Conf->Access == Access)
 409          return Conf;
 410
 411    // Create the new config class
 412    Conf = new MethodConfig;
 413    Conf->Access = Access;
 414    Conf->Next = Configs;
 415    Configs = Conf;
 416
 417    // Create the worker to fetch the configuration
 418    Worker Work(Conf);
 419    if (Work.Start() == false)
 420       return 0;
 421
 422    /* if a method uses DownloadLimit, we switch to SingleInstance mode */
 423    if(_config->FindI("Acquire::"+Access+"::Dl-Limit",0) > 0)
 424       Conf->SingleInstance = true;
 425
 426    return Conf;
 427 }
 428                                                                         /*}}}*/
 429 // Acquire::SetFds - Deal with readable FDs                             /*{{{*/
 430 // ---------------------------------------------------------------------
 431 /* Collect FDs that have activity monitors into the fd sets */
 432 void pkgAcquire::SetFds(int &Fd,fd_set *RSet,fd_set *WSet)
 433 {
 434    for (Worker *I = Workers; I != 0; I = I->NextAcquire)
 435    {
 436       if (I->InReady == true && I->InFd >= 0)
 437       {
 438          if (Fd < I->InFd)
 439             Fd = I->InFd;
 440          FD_SET(I->InFd,RSet);
 441       }
 442       if (I->OutReady == true && I->OutFd >= 0)
 443       {
 444          if (Fd < I->OutFd)
 445             Fd = I->OutFd;
 446          FD_SET(I->OutFd,WSet);
 447       }
 448    }
 449 }
 450                                                                         /*}}}*/
 451 // Acquire::RunFds - compatibility remove on next abi/api break         /*{{{*/
 452 void pkgAcquire::RunFds(fd_set *RSet,fd_set *WSet)
 453 {
 454    RunFdsSane(RSet, WSet);
 455 };
 456                                                                         /*}}}*/
 457 // Acquire::RunFdsSane - Deal with active FDs                           /*{{{*/
 458 // ---------------------------------------------------------------------
 459 /* Dispatch active FDs over to the proper workers. It is very important
 460    that a worker never be erased while this is running! The queue class
 461    should never erase a worker except during shutdown processing. */
 462 bool pkgAcquire::RunFdsSane(fd_set *RSet,fd_set *WSet)
 463 {
 464    bool Res = true;
 465
 466    for (Worker *I = Workers; I != 0; I = I->NextAcquire)
 467    {
 468       if (I->InFd >= 0 && FD_ISSET(I->InFd,RSet) != 0)
 469          Res &= I->InFdReady();
 470       if (I->OutFd >= 0 && FD_ISSET(I->OutFd,WSet) != 0)
 471          Res &= I->OutFdReady();
 472    }
 473
 474    return Res;
 475 }
 476                                                                         /*}}}*/
 477 // Acquire::Run - Run the fetch sequence                                /*{{{*/
 478 // ---------------------------------------------------------------------
 479 /* This runs the queues. It manages a select loop for all of the
 480    Worker tasks. The workers interact with the queues and items to
 481    manage the actual fetch. */
 482 static bool IsAccessibleBySandboxUser(std::string const &filename, bool const ReadWrite)
 483 {
 484    // you would think this is easily to answer with faccessat, right? Wrong!
 485    // It e.g. gets groups wrong, so the only thing which works reliable is trying
 486    // to open the file we want to open later on…
 487    if (unlikely(filename.empty()))
 488       return true;
 489
 490    if (ReadWrite == false)
 491    {
 492       errno = 0;
 493       // can we read a file? Note that non-existing files are "fine"
 494       int const fd = open(filename.c_str(), O_RDONLY | O_CLOEXEC);
 495       if (fd == -1 && errno == EACCES)
 496          return false;
 497       close(fd);
 498       return true;
 499    }
 500    else
 501    {
 502       // the file might not exist yet and even if it does we will fix permissions,
 503       // so important is here just that the directory it is in allows that
 504       std::string const dirname = flNotFile(filename);
 505       if (unlikely(dirname.empty()))
 506          return true;
 507
 508       char const * const filetag = ".apt-acquire-privs-test.XXXXXX";
 509       std::string const tmpfile_tpl = flCombine(dirname, filetag);
 510       std::unique_ptr<char, decltype(std::free) *> tmpfile { strdup(tmpfile_tpl.c_str()), std::free };
 511       int const fd = mkstemp(tmpfile.get());
 512       if (fd == -1 && errno == EACCES)
 513          return false;
 514       RemoveFile("IsAccessibleBySandboxUser", tmpfile.get());
 515       close(fd);
 516       return true;
 517    }
 518 }
 519 static void CheckDropPrivsMustBeDisabled(pkgAcquire const &Fetcher)
 520 {
 521    if(getuid() != 0)
 522       return;
 523
 524    std::string const SandboxUser = _config->Find("APT::Sandbox::User");
 525    if (SandboxUser.empty() || SandboxUser == "root")
 526       return;
 527
 528    struct passwd const * const pw = getpwnam(SandboxUser.c_str());
 529    if (pw == NULL)
 530    {
 531       _error->Warning(_("No sandbox user '%s' on the system, can not drop privileges"), SandboxUser.c_str());
 532       _config->Set("APT::Sandbox::User", "");
 533       return;
 534    }
 535
 536    gid_t const old_euid = geteuid();
 537    gid_t const old_egid = getegid();
 538
 539    long const ngroups_max = sysconf(_SC_NGROUPS_MAX);
 540    std::unique_ptr<gid_t[]> old_gidlist(new gid_t[ngroups_max]);
 541    if (unlikely(old_gidlist == NULL))
 542       return;
 543    ssize_t old_gidlist_nr;
 544    if ((old_gidlist_nr = getgroups(ngroups_max, old_gidlist.get())) < 0)
 545    {
 546       _error->FatalE("getgroups", "getgroups %lu failed", ngroups_max);
 547       old_gidlist[0] = 0;
 548       old_gidlist_nr = 1;
 549    }
 550    if (setgroups(1, &pw->pw_gid))
 551       _error->FatalE("setgroups", "setgroups %u failed", pw->pw_gid);
 552
 553    if (setegid(pw->pw_gid) != 0)
 554       _error->FatalE("setegid", "setegid %u failed", pw->pw_gid);
 555    if (seteuid(pw->pw_uid) != 0)
 556       _error->FatalE("seteuid", "seteuid %u failed", pw->pw_uid);
 557
 558    for (pkgAcquire::ItemCIterator I = Fetcher.ItemsBegin();
 559         I != Fetcher.ItemsEnd(); ++I)
 560    {
 561       // no need to drop privileges for a complete file
 562       if ((*I)->Complete == true)
 563          continue;
 564
 565       // if destination file is inaccessible all hope is lost for privilege dropping
 566       if (IsAccessibleBySandboxUser((*I)->DestFile, true) == false)
 567       {
 568          _error->WarningE("pkgAcquire::Run", _("Can't drop privileges for downloading as file '%s' couldn't be accessed by user '%s'."),
 569                (*I)->DestFile.c_str(), SandboxUser.c_str());
 570          _config->Set("APT::Sandbox::User", "");
 571          break;
 572       }
 573
 574       // if its the source file (e.g. local sources) we might be lucky
 575       // by dropping the dropping only for some methods.
 576       URI const source = (*I)->DescURI();
 577       if (source.Access == "file" || source.Access == "copy")
 578       {
 579          std::string const conf = "Binary::" + source.Access + "::APT::Sandbox::User";
 580          if (_config->Exists(conf) == true)
 581             continue;
 582
 583          if (IsAccessibleBySandboxUser(source.Path, false) == false)
 584          {
 585             _error->NoticeE("pkgAcquire::Run", _("Can't drop privileges for downloading as file '%s' couldn't be accessed by user '%s'."),
 586                   source.Path.c_str(), SandboxUser.c_str());
 587             _config->CndSet("Binary::file::APT::Sandbox::User", "root");
 588             _config->CndSet("Binary::copy::APT::Sandbox::User", "root");
 589          }
 590       }
 591    }
 592
 593    if (seteuid(old_euid) != 0)
 594       _error->FatalE("seteuid", "seteuid %u failed", old_euid);
 595    if (setegid(old_egid) != 0)
 596       _error->FatalE("setegid", "setegid %u failed", old_egid);
 597    if (setgroups(old_gidlist_nr, old_gidlist.get()))
 598       _error->FatalE("setgroups", "setgroups %u failed", 0);
 599 }
 600 pkgAcquire::RunResult pkgAcquire::Run(int PulseIntervall)
 601 {
 602    _error->PushToStack();
 603    CheckDropPrivsMustBeDisabled(*this);
 604
 605    Running = true;
 606
 607    for (Queue *I = Queues; I != 0; I = I->Next)
 608       I->Startup();
 609
 610    if (Log != 0)
 611       Log->Start();
 612
 613    bool WasCancelled = false;
 614
 615    // Run till all things have been acquired
 616    struct timeval tv;
 617    tv.tv_sec = 0;
 618    tv.tv_usec = PulseIntervall;
 619    while (ToFetch > 0)
 620    {
 621       fd_set RFds;
 622       fd_set WFds;
 623       int Highest = 0;
 624       FD_ZERO(&RFds);
 625       FD_ZERO(&WFds);
 626       SetFds(Highest,&RFds,&WFds);
 627
 628       int Res;
 629       do
 630       {
 631          Res = select(Highest+1,&RFds,&WFds,0,&tv);
 632       }
 633       while (Res < 0 && errno == EINTR);
 634
 635       if (Res < 0)
 636       {
 637          _error->Errno("select","Select has failed");
 638          break;
 639       }
 640
 641       if(RunFdsSane(&RFds,&WFds) == false)
 642          break;
 643
 644       // Timeout, notify the log class
 645       if (Res == 0 || (Log != 0 && Log->Update == true))
 646       {
 647          tv.tv_usec = PulseIntervall;
 648          for (Worker *I = Workers; I != 0; I = I->NextAcquire)
 649             I->Pulse();
 650          if (Log != 0 && Log->Pulse(this) == false)
 651          {
 652             WasCancelled = true;
 653             break;
 654          }
 655       }
 656    }
 657
 658    if (Log != 0)
 659       Log->Stop();
 660
 661    // Shut down the acquire bits
 662    Running = false;
 663    for (Queue *I = Queues; I != 0; I = I->Next)
 664       I->Shutdown(false);
 665
 666    // Shut down the items
 667    for (ItemIterator I = Items.begin(); I != Items.end(); ++I)
 668       (*I)->Finished();
 669
 670    bool const newError = _error->PendingError();
 671    _error->MergeWithStack();
 672    if (newError)
 673       return Failed;
 674    if (WasCancelled)
 675       return Cancelled;
 676    return Continue;
 677 }
 678                                                                         /*}}}*/
 679 // Acquire::Bump - Called when an item is dequeued                      /*{{{*/
 680 // ---------------------------------------------------------------------
 681 /* This routine bumps idle queues in hopes that they will be able to fetch
 682    the dequeued item */
 683 void pkgAcquire::Bump()
 684 {
 685    for (Queue *I = Queues; I != 0; I = I->Next)
 686       I->Bump();
 687 }
 688                                                                         /*}}}*/
 689 // Acquire::WorkerStep - Step to the next worker                        /*{{{*/
 690 // ---------------------------------------------------------------------
 691 /* Not inlined to advoid including acquire-worker.h */
 692 pkgAcquire::Worker *pkgAcquire::WorkerStep(Worker *I)
 693 {
 694    return I->NextAcquire;
 695 }
 696                                                                         /*}}}*/
 697 // Acquire::Clean - Cleans a directory                                  /*{{{*/
 698 // ---------------------------------------------------------------------
 699 /* This is a bit simplistic, it looks at every file in the dir and sees
 700    if it is part of the download set. */
 701 bool pkgAcquire::Clean(string Dir)
 702 {
 703    // non-existing directories are by definition clean…
 704    if (DirectoryExists(Dir) == false)
 705       return true;
 706
 707    if(Dir == "/")
 708       return _error->Error(_("Clean of %s is not supported"), Dir.c_str());
 709
 710    DIR *D = opendir(Dir.c_str());
 711    if (D == 0)
 712       return _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
 713
 714    string StartDir = SafeGetCWD();
 715    if (chdir(Dir.c_str()) != 0)
 716    {
 717       closedir(D);
 718       return _error->Errno("chdir",_("Unable to change to %s"),Dir.c_str());
 719    }
 720
 721    for (struct dirent *Dir = readdir(D); Dir != 0; Dir = readdir(D))
 722    {
 723       // Skip some files..
 724       if (strcmp(Dir->d_name,"lock") == 0 ||
 725           strcmp(Dir->d_name,"partial") == 0 ||
 726           strcmp(Dir->d_name,"lost+found") == 0 ||
 727           strcmp(Dir->d_name,".") == 0 ||
 728           strcmp(Dir->d_name,"..") == 0)
 729          continue;
 730
 731       // Look in the get list
 732       ItemCIterator I = Items.begin();
 733       for (; I != Items.end(); ++I)
 734          if (flNotDir((*I)->DestFile) == Dir->d_name)
 735             break;
 736
 737       // Nothing found, nuke it
 738       if (I == Items.end())
 739          RemoveFile("Clean", Dir->d_name);
 740    };
 741
 742    closedir(D);
 743    if (chdir(StartDir.c_str()) != 0)
 744       return _error->Errno("chdir",_("Unable to change to %s"),StartDir.c_str());
 745    return true;
 746 }
 747                                                                         /*}}}*/
 748 // Acquire::TotalNeeded - Number of bytes to fetch                      /*{{{*/
 749 // ---------------------------------------------------------------------
 750 /* This is the total number of bytes needed */
 751 APT_PURE unsigned long long pkgAcquire::TotalNeeded()
 752 {
 753    return std::accumulate(ItemsBegin(), ItemsEnd(), 0llu,
 754       [](unsigned long long const T, Item const * const I) {
 755          return T + I->FileSize;
 756    });
 757 }
 758                                                                         /*}}}*/
 759 // Acquire::FetchNeeded - Number of bytes needed to get                 /*{{{*/
 760 // ---------------------------------------------------------------------
 761 /* This is the number of bytes that is not local */
 762 APT_PURE unsigned long long pkgAcquire::FetchNeeded()
 763 {
 764    return std::accumulate(ItemsBegin(), ItemsEnd(), 0llu,
 765       [](unsigned long long const T, Item const * const I) {
 766          if (I->Local == false)
 767             return T + I->FileSize;
 768          else
 769             return T;
 770    });
 771 }
 772                                                                         /*}}}*/
 773 // Acquire::PartialPresent - Number of partial bytes we already have    /*{{{*/
 774 // ---------------------------------------------------------------------
 775 /* This is the number of bytes that is not local */
 776 APT_PURE unsigned long long pkgAcquire::PartialPresent()
 777 {
 778    return std::accumulate(ItemsBegin(), ItemsEnd(), 0llu,
 779       [](unsigned long long const T, Item const * const I) {
 780          if (I->Local == false)
 781             return T + I->PartialSize;
 782          else
 783             return T;
 784    });
 785 }
 786                                                                         /*}}}*/
 787 // Acquire::UriBegin - Start iterator for the uri list                  /*{{{*/
 788 // ---------------------------------------------------------------------
 789 /* */
 790 pkgAcquire::UriIterator pkgAcquire::UriBegin()
 791 {
 792    return UriIterator(Queues);
 793 }
 794                                                                         /*}}}*/
 795 // Acquire::UriEnd - End iterator for the uri list                      /*{{{*/
 796 // ---------------------------------------------------------------------
 797 /* */
 798 pkgAcquire::UriIterator pkgAcquire::UriEnd()
 799 {
 800    return UriIterator(0);
 801 }
 802                                                                         /*}}}*/
 803 // Acquire::MethodConfig::MethodConfig - Constructor                    /*{{{*/
 804 // ---------------------------------------------------------------------
 805 /* */
 806 pkgAcquire::MethodConfig::MethodConfig() : d(NULL), Next(0), SingleInstance(false),
 807    Pipeline(false), SendConfig(false), LocalOnly(false), NeedsCleanup(false),
 808    Removable(false)
 809 {
 810 }
 811                                                                         /*}}}*/
 812 // Queue::Queue - Constructor                                           /*{{{*/
 813 // ---------------------------------------------------------------------
 814 /* */
 815 pkgAcquire::Queue::Queue(string const &name,pkgAcquire * const owner) : d(NULL), Next(0),
 816    Name(name), Items(0), Workers(0), Owner(owner), PipeDepth(0), MaxPipeDepth(1)
 817 {
 818 }
 819                                                                         /*}}}*/
 820 // Queue::~Queue - Destructor                                           /*{{{*/
 821 // ---------------------------------------------------------------------
 822 /* */
 823 pkgAcquire::Queue::~Queue()
 824 {
 825    Shutdown(true);
 826
 827    while (Items != 0)
 828    {
 829       QItem *Jnk = Items;
 830       Items = Items->Next;
 831       delete Jnk;
 832    }
 833 }
 834                                                                         /*}}}*/
 835 // Queue::Enqueue - Queue an item to the queue                          /*{{{*/
 836 // ---------------------------------------------------------------------
 837 /* */
 838 bool pkgAcquire::Queue::Enqueue(ItemDesc &Item)
 839 {
 840    QItem **I = &Items;
 841    // move to the end of the queue and check for duplicates here
 842    for (; *I != 0; I = &(*I)->Next)
 843       if (Item.URI == (*I)->URI)
 844       {
 845          if (_config->FindB("Debug::pkgAcquire::Worker",false) == true)
 846             std::cerr << " @ Queue: Action combined for " << Item.URI << " and " << (*I)->URI << std::endl;
 847          (*I)->Owners.push_back(Item.Owner);
 848          Item.Owner->Status = (*I)->Owner->Status;
 849          return false;
 850       }
 851
 852    // Create a new item
 853    QItem *Itm = new QItem;
 854    *Itm = Item;
 855    Itm->Next = 0;
 856    *I = Itm;
 857
 858    Item.Owner->QueueCounter++;
 859    if (Items->Next == 0)
 860       Cycle();
 861    return true;
 862 }
 863                                                                         /*}}}*/
 864 // Queue::Dequeue - Remove an item from the queue                       /*{{{*/
 865 // ---------------------------------------------------------------------
 866 /* We return true if we hit something */
 867 bool pkgAcquire::Queue::Dequeue(Item *Owner)
 868 {
 869    if (Owner->Status == pkgAcquire::Item::StatFetching)
 870       return _error->Error("Tried to dequeue a fetching object");
 871
 872    bool Res = false;
 873
 874    QItem **I = &Items;
 875    for (; *I != 0;)
 876    {
 877       if (Owner == (*I)->Owner)
 878       {
 879          QItem *Jnk= *I;
 880          *I = (*I)->Next;
 881          Owner->QueueCounter--;
 882          delete Jnk;
 883          Res = true;
 884       }
 885       else
 886          I = &(*I)->Next;
 887    }
 888
 889    return Res;
 890 }
 891                                                                         /*}}}*/
 892 // Queue::Startup - Start the worker processes                          /*{{{*/
 893 // ---------------------------------------------------------------------
 894 /* It is possible for this to be called with a pre-existing set of
 895    workers. */
 896 bool pkgAcquire::Queue::Startup()
 897 {
 898    if (Workers == 0)
 899    {
 900       URI U(Name);
 901       pkgAcquire::MethodConfig *Cnf = Owner->GetConfig(U.Access);
 902       if (Cnf == 0)
 903          return false;
 904
 905       Workers = new Worker(this,Cnf,Owner->Log);
 906       Owner->Add(Workers);
 907       if (Workers->Start() == false)
 908          return false;
 909
 910       /* When pipelining we commit 10 items. This needs to change when we
 911          added other source retry to have cycle maintain a pipeline depth
 912          on its own. */
 913       if (Cnf->Pipeline == true)
 914          MaxPipeDepth = _config->FindI("Acquire::Max-Pipeline-Depth",10);
 915       else
 916          MaxPipeDepth = 1;
 917    }
 918
 919    return Cycle();
 920 }
 921                                                                         /*}}}*/
 922 // Queue::Shutdown - Shutdown the worker processes                      /*{{{*/
 923 // ---------------------------------------------------------------------
 924 /* If final is true then all workers are eliminated, otherwise only workers
 925    that do not need cleanup are removed */
 926 bool pkgAcquire::Queue::Shutdown(bool Final)
 927 {
 928    // Delete all of the workers
 929    pkgAcquire::Worker **Cur = &Workers;
 930    while (*Cur != 0)
 931    {
 932       pkgAcquire::Worker *Jnk = *Cur;
 933       if (Final == true || Jnk->GetConf()->NeedsCleanup == false)
 934       {
 935          *Cur = Jnk->NextQueue;
 936          Owner->Remove(Jnk);
 937          delete Jnk;
 938       }
 939       else
 940          Cur = &(*Cur)->NextQueue;
 941    }
 942
 943    return true;
 944 }
 945                                                                         /*}}}*/
 946 // Queue::FindItem - Find a URI in the item list                        /*{{{*/
 947 // ---------------------------------------------------------------------
 948 /* */
 949 pkgAcquire::Queue::QItem *pkgAcquire::Queue::FindItem(string URI,pkgAcquire::Worker *Owner)
 950 {
 951    for (QItem *I = Items; I != 0; I = I->Next)
 952       if (I->URI == URI && I->Worker == Owner)
 953          return I;
 954    return 0;
 955 }
 956                                                                         /*}}}*/
 957 // Queue::ItemDone - Item has been completed                            /*{{{*/
 958 // ---------------------------------------------------------------------
 959 /* The worker signals this which causes the item to be removed from the
 960    queue. If this is the last queue instance then it is removed from the
 961    main queue too.*/
 962 bool pkgAcquire::Queue::ItemDone(QItem *Itm)
 963 {
 964    PipeDepth--;
 965    for (QItem::owner_iterator O = Itm->Owners.begin(); O != Itm->Owners.end(); ++O)
 966    {
 967       if ((*O)->Status == pkgAcquire::Item::StatFetching)
 968          (*O)->Status = pkgAcquire::Item::StatDone;
 969    }
 970
 971    if (Itm->Owner->QueueCounter <= 1)
 972       Owner->Dequeue(Itm->Owner);
 973    else
 974    {
 975       Dequeue(Itm->Owner);
 976       Owner->Bump();
 977    }
 978
 979    return Cycle();
 980 }
 981                                                                         /*}}}*/
 982 // Queue::Cycle - Queue new items into the method                       /*{{{*/
 983 // ---------------------------------------------------------------------
 984 /* This locates a new idle item and sends it to the worker. If pipelining
 985    is enabled then it keeps the pipe full. */
 986 bool pkgAcquire::Queue::Cycle()
 987 {
 988    if (Items == 0 || Workers == 0)
 989       return true;
 990
 991    if (PipeDepth < 0)
 992       return _error->Error("Pipedepth failure");
 993
 994    // Look for a queable item
 995    QItem *I = Items;
 996    while (PipeDepth < (signed)MaxPipeDepth)
 997    {
 998       for (; I != 0; I = I->Next)
 999          if (I->Owner->Status == pkgAcquire::Item::StatIdle)
1000             break;
1001
1002       // Nothing to do, queue is idle.
1003       if (I == 0)
1004          return true;
1005
1006       I->Worker = Workers;
1007       for (auto const &O: I->Owners)
1008          O->Status = pkgAcquire::Item::StatFetching;
1009       PipeDepth++;
1010       if (Workers->QueueItem(I) == false)
1011          return false;
1012    }
1013
1014    return true;
1015 }
1016                                                                         /*}}}*/
1017 // Queue::Bump - Fetch any pending objects if we are idle               /*{{{*/
1018 // ---------------------------------------------------------------------
1019 /* This is called when an item in multiple queues is dequeued */
1020 void pkgAcquire::Queue::Bump()
1021 {
1022    Cycle();
1023 }
1024                                                                         /*}}}*/
1025 HashStringList pkgAcquire::Queue::QItem::GetExpectedHashes() const      /*{{{*/
1026 {
1027    /* each Item can have multiple owners and each owner might have different
1028       hashes, even if that is unlikely in practice and if so at least some
1029       owners will later fail. There is one situation through which is not a
1030       failure and still needs this handling: Two owners who expect the same
1031       file, but one owner only knows the SHA1 while the other only knows SHA256. */
1032    HashStringList superhsl;
1033    for (pkgAcquire::Queue::QItem::owner_iterator O = Owners.begin(); O != Owners.end(); ++O)
1034    {
1035       HashStringList const hsl = (*O)->GetExpectedHashes();
1036       if (hsl.usable() == false)
1037          continue;
1038       if (superhsl.usable() == false)
1039          superhsl = hsl;
1040       else
1041       {
1042          // we merge both lists - if we find disagreement send no hashes
1043          HashStringList::const_iterator hs = hsl.begin();
1044          for (; hs != hsl.end(); ++hs)
1045             if (superhsl.push_back(*hs) == false)
1046                break;
1047          if (hs != hsl.end())
1048          {
1049             superhsl.clear();
1050             break;
1051          }
1052       }
1053    }
1054    return superhsl;
1055 }
1056                                                                         /*}}}*/
1057 APT_PURE unsigned long long pkgAcquire::Queue::QItem::GetMaximumSize() const    /*{{{*/
1058 {
1059    unsigned long long Maximum = std::numeric_limits<unsigned long long>::max();
1060    for (auto const &O: Owners)
1061    {
1062       if (O->FileSize == 0)
1063          continue;
1064       Maximum = std::min(Maximum, O->FileSize);
1065    }
1066    if (Maximum == std::numeric_limits<unsigned long long>::max())
1067       return 0;
1068    return Maximum;
1069 }
1070                                                                         /*}}}*/
1071 void pkgAcquire::Queue::QItem::SyncDestinationFiles() const             /*{{{*/
1072 {
1073    /* ensure that the first owner has the best partial file of all and
1074       the rest have (potentially dangling) symlinks to it so that
1075       everything (like progress reporting) finds it easily */
1076    std::string superfile = Owner->DestFile;
1077    off_t supersize = 0;
1078    for (pkgAcquire::Queue::QItem::owner_iterator O = Owners.begin(); O != Owners.end(); ++O)
1079    {
1080       if ((*O)->DestFile == superfile)
1081          continue;
1082       struct stat file;
1083       if (lstat((*O)->DestFile.c_str(),&file) == 0)
1084       {
1085          if ((file.st_mode & S_IFREG) == 0)
1086             RemoveFile("SyncDestinationFiles", (*O)->DestFile);
1087          else if (supersize < file.st_size)
1088          {
1089             supersize = file.st_size;
1090             RemoveFile("SyncDestinationFiles", superfile);
1091             rename((*O)->DestFile.c_str(), superfile.c_str());
1092          }
1093          else
1094             RemoveFile("SyncDestinationFiles", (*O)->DestFile);
1095          if (symlink(superfile.c_str(), (*O)->DestFile.c_str()) != 0)
1096          {
1097             ; // not a problem per-se and no real alternative
1098          }
1099       }
1100    }
1101 }
1102                                                                         /*}}}*/
1103 std::string pkgAcquire::Queue::QItem::Custom600Headers() const          /*{{{*/
1104 {
1105    /* The others are relatively easy to merge, but this one?
1106       Lets not merge and see how far we can run with it…
1107       Likely, nobody will ever notice as all the items will
1108       be of the same class and hence generate the same headers. */
1109    return Owner->Custom600Headers();
1110 }
1111                                                                         /*}}}*/
1112
1113 // AcquireStatus::pkgAcquireStatus - Constructor                        /*{{{*/
1114 // ---------------------------------------------------------------------
1115 /* */
1116 pkgAcquireStatus::pkgAcquireStatus() : d(NULL), Percent(-1), Update(true), MorePulses(false)
1117 {
1118    Start();
1119 }
1120                                                                         /*}}}*/
1121 // AcquireStatus::Pulse - Called periodically                           /*{{{*/
1122 // ---------------------------------------------------------------------
1123 /* This computes some internal state variables for the derived classes to
1124    use. It generates the current downloaded bytes and total bytes to download
1125    as well as the current CPS estimate. */
1126 bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
1127 {
1128    TotalBytes = 0;
1129    CurrentBytes = 0;
1130    TotalItems = 0;
1131    CurrentItems = 0;
1132
1133    // Compute the total number of bytes to fetch
1134    unsigned int Unknown = 0;
1135    unsigned int Count = 0;
1136    bool UnfetchedReleaseFiles = false;
1137    for (pkgAcquire::ItemCIterator I = Owner->ItemsBegin();
1138         I != Owner->ItemsEnd();
1139         ++I, ++Count)
1140    {
1141       TotalItems++;
1142       if ((*I)->Status == pkgAcquire::Item::StatDone)
1143          ++CurrentItems;
1144
1145       // Totally ignore local items
1146       if ((*I)->Local == true)
1147          continue;
1148
1149       // see if the method tells us to expect more
1150       TotalItems += (*I)->ExpectedAdditionalItems;
1151
1152       // check if there are unfetched Release files
1153       if ((*I)->Complete == false && (*I)->ExpectedAdditionalItems > 0)
1154          UnfetchedReleaseFiles = true;
1155
1156       TotalBytes += (*I)->FileSize;
1157       if ((*I)->Complete == true)
1158          CurrentBytes += (*I)->FileSize;
1159       if ((*I)->FileSize == 0 && (*I)->Complete == false)
1160          ++Unknown;
1161    }
1162
1163    // Compute the current completion
1164    unsigned long long ResumeSize = 0;
1165    for (pkgAcquire::Worker *I = Owner->WorkersBegin(); I != 0;
1166         I = Owner->WorkerStep(I))
1167    {
1168       if (I->CurrentItem != 0 && I->CurrentItem->Owner->Complete == false)
1169       {
1170          CurrentBytes += I->CurrentSize;
1171          ResumeSize += I->ResumePoint;
1172
1173          // Files with unknown size always have 100% completion
1174          if (I->CurrentItem->Owner->FileSize == 0 &&
1175              I->CurrentItem->Owner->Complete == false)
1176             TotalBytes += I->CurrentSize;
1177       }
1178    }
1179
1180    // Normalize the figures and account for unknown size downloads
1181    if (TotalBytes <= 0)
1182       TotalBytes = 1;
1183    if (Unknown == Count)
1184       TotalBytes = Unknown;
1185
1186    // Wha?! Is not supposed to happen.
1187    if (CurrentBytes > TotalBytes)
1188       CurrentBytes = TotalBytes;
1189
1190    // debug
1191    if (_config->FindB("Debug::acquire::progress", false) == true)
1192       std::clog << " Bytes: "
1193                 << SizeToStr(CurrentBytes) << " / " << SizeToStr(TotalBytes)
1194                 << std::endl;
1195
1196    // Compute the CPS
1197    struct timeval NewTime;
1198    gettimeofday(&NewTime,0);
1199    if ((NewTime.tv_sec - Time.tv_sec == 6 && NewTime.tv_usec > Time.tv_usec) ||
1200        NewTime.tv_sec - Time.tv_sec > 6)
1201    {
1202       double Delta = NewTime.tv_sec - Time.tv_sec +
1203                      (NewTime.tv_usec - Time.tv_usec)/1000000.0;
1204
1205       // Compute the CPS value
1206       if (Delta < 0.01)
1207          CurrentCPS = 0;
1208       else
1209          CurrentCPS = ((CurrentBytes - ResumeSize) - LastBytes)/Delta;
1210       LastBytes = CurrentBytes - ResumeSize;
1211       ElapsedTime = (unsigned long long)Delta;
1212       Time = NewTime;
1213    }
1214
1215    double const OldPercent = Percent;
1216    // calculate the percentage, if we have too little data assume 1%
1217    if (TotalBytes > 0 && UnfetchedReleaseFiles)
1218       Percent = 0;
1219    else
1220       // use both files and bytes because bytes can be unreliable
1221       Percent = (0.8 * (CurrentBytes/float(TotalBytes)*100.0) +
1222                  0.2 * (CurrentItems/float(TotalItems)*100.0));
1223    double const DiffPercent = Percent - OldPercent;
1224    if (DiffPercent < 0.001 && _config->FindB("Acquire::Progress::Diffpercent", false) == true)
1225       return true;
1226
1227    int fd = _config->FindI("APT::Status-Fd",-1);
1228    if(fd > 0)
1229    {
1230       ostringstream status;
1231
1232       char msg[200];
1233       long i = CurrentItems < TotalItems ? CurrentItems + 1 : CurrentItems;
1234       unsigned long long ETA = 0;
1235       if(CurrentCPS > 0)
1236          ETA = (TotalBytes - CurrentBytes) / CurrentCPS;
1237
1238       // only show the ETA if it makes sense
1239       if (ETA > 0 && ETA < 172800 /* two days */ )
1240          snprintf(msg,sizeof(msg), _("Retrieving file %li of %li (%s remaining)"), i, TotalItems, TimeToStr(ETA).c_str());
1241       else
1242          snprintf(msg,sizeof(msg), _("Retrieving file %li of %li"), i, TotalItems);
1243
1244       // build the status str
1245       status << "dlstatus:" << i
1246              << ":"  << std::setprecision(3) << Percent
1247              << ":" << msg
1248              << endl;
1249
1250       std::string const dlstatus = status.str();
1251       FileFd::Write(fd, dlstatus.c_str(), dlstatus.size());
1252    }
1253
1254    return true;
1255 }
1256                                                                         /*}}}*/
1257 // AcquireStatus::Start - Called when the download is started           /*{{{*/
1258 // ---------------------------------------------------------------------
1259 /* We just reset the counters */
1260 void pkgAcquireStatus::Start()
1261 {
1262    gettimeofday(&Time,0);
1263    gettimeofday(&StartTime,0);
1264    LastBytes = 0;
1265    CurrentCPS = 0;
1266    CurrentBytes = 0;
1267    TotalBytes = 0;
1268    FetchedBytes = 0;
1269    ElapsedTime = 0;
1270    TotalItems = 0;
1271    CurrentItems = 0;
1272 }
1273                                                                         /*}}}*/
1274 // AcquireStatus::Stop - Finished downloading                           /*{{{*/
1275 // ---------------------------------------------------------------------
1276 /* This accurately computes the elapsed time and the total overall CPS. */
1277 void pkgAcquireStatus::Stop()
1278 {
1279    // Compute the CPS and elapsed time
1280    struct timeval NewTime;
1281    gettimeofday(&NewTime,0);
1282
1283    double Delta = NewTime.tv_sec - StartTime.tv_sec +
1284                   (NewTime.tv_usec - StartTime.tv_usec)/1000000.0;
1285
1286    // Compute the CPS value
1287    if (Delta < 0.01)
1288       CurrentCPS = 0;
1289    else
1290       CurrentCPS = FetchedBytes/Delta;
1291    LastBytes = CurrentBytes;
1292    ElapsedTime = (unsigned long long)Delta;
1293 }
1294                                                                         /*}}}*/
1295 // AcquireStatus::Fetched - Called when a byte set has been fetched     /*{{{*/
1296 // ---------------------------------------------------------------------
1297 /* This is used to get accurate final transfer rate reporting. */
1298 void pkgAcquireStatus::Fetched(unsigned long long Size,unsigned long long Resume)
1299 {
1300    FetchedBytes += Size - Resume;
1301 }
1302                                                                         /*}}}*/
1303
1304 pkgAcquire::UriIterator::UriIterator(pkgAcquire::Queue *Q) : d(NULL), CurQ(Q), CurItem(0)
1305 {
1306    while (CurItem == 0 && CurQ != 0)
1307    {
1308       CurItem = CurQ->Items;
1309       CurQ = CurQ->Next;
1310    }
1311 }
1312
1313 APT_CONST pkgAcquire::UriIterator::~UriIterator() {}
1314 APT_CONST pkgAcquire::MethodConfig::~MethodConfig() {}
1315 APT_CONST pkgAcquireStatus::~pkgAcquireStatus() {}