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