apt-private/private-install.cc

   1 // Include Files                                                        /*{{{*/
   2 #include <config.h>
   3
   4 #include <apt-pkg/acquire.h>
   5 #include <apt-pkg/acquire-item.h>
   6 #include <apt-pkg/algorithms.h>
   7 #include <apt-pkg/cachefile.h>
   8 #include <apt-pkg/cacheset.h>
   9 #include <apt-pkg/cmndline.h>
  10 #include <apt-pkg/depcache.h>
  11 #include <apt-pkg/error.h>
  12 #include <apt-pkg/fileutl.h>
  13 #include <apt-pkg/pkgrecords.h>
  14 #include <apt-pkg/pkgsystem.h>
  15 #include <apt-pkg/sptr.h>
  16 #include <apt-pkg/strutl.h>
  17 #include <apt-pkg/cacheiterators.h>
  18 #include <apt-pkg/configuration.h>
  19 #include <apt-pkg/macros.h>
  20 #include <apt-pkg/packagemanager.h>
  21 #include <apt-pkg/pkgcache.h>
  22 #include <apt-pkg/upgrade.h>
  23 #include <apt-pkg/install-progress.h>
  24 #include <apt-pkg/prettyprinters.h>
  25
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <algorithm>
  29 #include <iostream>
  30 #include <set>
  31 #include <vector>
  32 #include <map>
  33
  34 #include <apt-private/acqprogress.h>
  35 #include <apt-private/private-install.h>
  36 #include <apt-private/private-cachefile.h>
  37 #include <apt-private/private-cacheset.h>
  38 #include <apt-private/private-download.h>
  39 #include <apt-private/private-output.h>
  40
  41 #include <apti18n.h>
  42                                                                         /*}}}*/
  43 class pkgSourceList;
  44
  45 bool CheckNothingBroken(CacheFile &Cache)                               /*{{{*/
  46 {
  47    // Now we check the state of the packages,
  48    if (Cache->BrokenCount() == 0)
  49       return true;
  50
  51    // FIXME: if an external solver showed an error, we shouldn't show one here
  52    if (_error->PendingError() && _config->Find("APT::Solver") == "dump")
  53       return false;
  54
  55    c1out <<
  56       _("Some packages could not be installed. This may mean that you have\n"
  57             "requested an impossible situation or if you are using the unstable\n"
  58             "distribution that some required packages have not yet been created\n"
  59             "or been moved out of Incoming.") << std::endl;
  60    /*
  61    if (Packages == 1)
  62    {
  63       c1out << std::endl;
  64       c1out <<
  65          _("Since you only requested a single operation it is extremely likely that\n"
  66                "the package is simply not installable and a bug report against\n"
  67                "that package should be filed.") << std::endl;
  68    }
  69    */
  70
  71    c1out << _("The following information may help to resolve the situation:") << std::endl;
  72    c1out << std::endl;
  73    ShowBroken(c1out,Cache,false);
  74    if (_error->PendingError() == true)
  75       return false;
  76    else
  77       return _error->Error(_("Broken packages"));
  78 }
  79                                                                         /*}}}*/
  80 // InstallPackages - Actually download and install the packages         /*{{{*/
  81 // ---------------------------------------------------------------------
  82 /* This displays the informative messages describing what is going to
  83    happen and then calls the download routines */
  84 static void RemoveDownloadNeedingItemsFromFetcher(pkgAcquire &Fetcher, bool &Transient)
  85 {
  86    for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I < Fetcher.ItemsEnd();)
  87    {
  88       if ((*I)->Local == true)
  89       {
  90          ++I;
  91          continue;
  92       }
  93
  94       // Close the item and check if it was found in cache
  95       (*I)->Finished();
  96       if ((*I)->Complete == false)
  97          Transient = true;
  98
  99       // Clear it out of the fetch list
 100       delete *I;
 101       I = Fetcher.ItemsBegin();
 102    }
 103 }
 104 bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask, bool Safety)
 105 {
 106    if (_config->FindB("APT::Get::Purge", false) == true)
 107       for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; ++I)
 108          if (Cache[I].Delete() == true && Cache[I].Purge() == false)
 109             Cache->MarkDelete(I,true);
 110
 111    // Create the download object
 112    aptAcquireWithTextStatus Fetcher;
 113    if (_config->FindB("APT::Get::Print-URIs", false) == true)
 114    {
 115       // force a hashsum for compatibility reasons
 116       _config->CndSet("Acquire::ForceHash", "md5sum");
 117    }
 118    else if (_config->FindB("APT::Get::Simulate") == true)
 119       ;
 120    else if (Fetcher.GetLock(_config->FindDir("Dir::Cache::Archives")) == false)
 121       return false;
 122
 123    // Read the source list
 124    if (Cache.BuildSourceList() == false)
 125       return false;
 126    pkgSourceList * const List = Cache.GetSourceList();
 127
 128    // Create the text record parser
 129    pkgRecords Recs(Cache);
 130    if (_error->PendingError() == true)
 131       return false;
 132
 133    // Create the package manager and prepare to download
 134    std::unique_ptr<pkgPackageManager> PM(_system->CreatePM(Cache));
 135    if (PM->GetArchives(&Fetcher,List,&Recs) == false ||
 136        _error->PendingError() == true)
 137       return false;
 138
 139    if (_config->FindB("APT::Get::Fix-Missing",false) == true &&
 140          _config->FindB("APT::Get::Download",true) == false)
 141    {
 142       bool Missing = false;
 143       RemoveDownloadNeedingItemsFromFetcher(Fetcher, Missing);
 144       if (Missing)
 145          PM->FixMissing();
 146       Fetcher.Shutdown();
 147       if (PM->GetArchives(&Fetcher,List,&Recs) == false ||
 148             _error->PendingError() == true)
 149          return false;
 150    }
 151
 152    // Show all the various warning indicators
 153    ShowDel(c1out,Cache);
 154    ShowNew(c1out,Cache);
 155    if (ShwKept == true)
 156       ShowKept(c1out,Cache);
 157    bool const Hold = !ShowHold(c1out,Cache);
 158    if (_config->FindB("APT::Get::Show-Upgraded",true) == true)
 159       ShowUpgraded(c1out,Cache);
 160    bool const Downgrade = !ShowDowngraded(c1out,Cache);
 161
 162    bool Essential = false;
 163    if (_config->FindB("APT::Get::Download-Only",false) == false)
 164         Essential = !ShowEssential(c1out,Cache);
 165
 166    Stats(c1out,Cache);
 167
 168    // Sanity check
 169    if (Cache->BrokenCount() != 0)
 170    {
 171       ShowBroken(c1out,Cache,false);
 172       return _error->Error(_("Internal error, InstallPackages was called with broken packages!"));
 173    }
 174
 175    if (Cache->DelCount() == 0 && Cache->InstCount() == 0 &&
 176        Cache->BadCount() == 0)
 177       return true;
 178
 179    // No remove flag
 180    if (Cache->DelCount() != 0 && _config->FindB("APT::Get::Remove",true) == false)
 181       return _error->Error(_("Packages need to be removed but remove is disabled."));
 182
 183    // Fail safe check
 184    bool const Fail = (Essential || Downgrade || Hold);
 185    if (_config->FindI("quiet",0) >= 2 ||
 186        _config->FindB("APT::Get::Assume-Yes",false) == true)
 187    {
 188       if (_config->FindB("APT::Get::Force-Yes",false) == true) {
 189          _error->Warning(_("--force-yes is deprecated, use one of the options starting with --allow instead."));
 190       }
 191
 192       if (Fail == true && _config->FindB("APT::Get::Force-Yes",false) == false) {
 193          if (Essential == true && _config->FindB("APT::Get::allow-remove-essential", false) == false)
 194             return _error->Error(_("Essential packages were removed and -y was used without --allow-remove-essential."));
 195          if (Downgrade == true && _config->FindB("APT::Get::allow-downgrades", false) == false)
 196             return _error->Error(_("Packages were downgraded and -y was used without --allow-downgrades."));
 197          if (Hold == true && _config->FindB("APT::Get::allow-change-held-packages", false) == false)
 198             return _error->Error(_("Held packages were changed and -y was used without --allow-change-held-packages."));
 199       }
 200    }
 201
 202    // Run the simulator ..
 203    if (_config->FindB("APT::Get::Simulate") == true)
 204    {
 205       pkgSimulate PM(Cache);
 206
 207       APT::Progress::PackageManager *progress = APT::Progress::PackageManagerProgressFactory();
 208       pkgPackageManager::OrderResult Res = PM.DoInstall(progress);
 209       delete progress;
 210
 211       if (Res == pkgPackageManager::Failed)
 212          return false;
 213       if (Res != pkgPackageManager::Completed)
 214          return _error->Error(_("Internal error, Ordering didn't finish"));
 215       return true;
 216    }
 217
 218    // Display statistics
 219    auto const FetchBytes = Fetcher.FetchNeeded();
 220    auto const FetchPBytes = Fetcher.PartialPresent();
 221    auto const DebBytes = Fetcher.TotalNeeded();
 222    if (DebBytes != Cache->DebSize())
 223    {
 224       c0out << DebBytes << ',' << Cache->DebSize() << std::endl;
 225       c0out << _("How odd... The sizes didn't match, email apt@packages.debian.org") << std::endl;
 226    }
 227
 228    // Number of bytes
 229    if (DebBytes != FetchBytes)
 230       //TRANSLATOR: The required space between number and unit is already included
 231       // in the replacement strings, so %sB will be correctly translate in e.g. 1,5 MB
 232       ioprintf(c1out,_("Need to get %sB/%sB of archives.\n"),
 233                SizeToStr(FetchBytes).c_str(),SizeToStr(DebBytes).c_str());
 234    else if (DebBytes != 0)
 235       //TRANSLATOR: The required space between number and unit is already included
 236       // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
 237       ioprintf(c1out,_("Need to get %sB of archives.\n"),
 238                SizeToStr(DebBytes).c_str());
 239
 240    // Size delta
 241    if (Cache->UsrSize() >= 0)
 242       //TRANSLATOR: The required space between number and unit is already included
 243       // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
 244       ioprintf(c1out,_("After this operation, %sB of additional disk space will be used.\n"),
 245                SizeToStr(Cache->UsrSize()).c_str());
 246    else
 247       //TRANSLATOR: The required space between number and unit is already included
 248       // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
 249       ioprintf(c1out,_("After this operation, %sB disk space will be freed.\n"),
 250                SizeToStr(-1*Cache->UsrSize()).c_str());
 251
 252    if (CheckFreeSpaceBeforeDownload(_config->FindDir("Dir::Cache::Archives"), (FetchBytes - FetchPBytes)) == false)
 253       return false;
 254
 255    if (_error->PendingError() == true)
 256       return false;
 257
 258    // Just print out the uris an exit if the --print-uris flag was used
 259    if (_config->FindB("APT::Get::Print-URIs") == true)
 260    {
 261       pkgAcquire::UriIterator I = Fetcher.UriBegin();
 262       for (; I != Fetcher.UriEnd(); ++I)
 263          std::cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
 264                std::to_string(I->Owner->FileSize) << ' ' << I->Owner->HashSum() << std::endl;
 265       return true;
 266    }
 267
 268    if (Essential == true && Safety == true && _config->FindB("APT::Get::allow-remove-essential", false) == false)
 269    {
 270       if (_config->FindB("APT::Get::Trivial-Only",false) == true)
 271          return _error->Error(_("Trivial Only specified but this is not a trivial operation."));
 272
 273       // TRANSLATOR: This string needs to be typed by the user as a confirmation, so be
 274       //             careful with hard to type or special characters (like non-breaking spaces)
 275       const char *Prompt = _("Yes, do as I say!");
 276       std::string question;
 277       strprintf(question,
 278                _("You are about to do something potentially harmful.\n"
 279                  "To continue type in the phrase '%s'\n"
 280                  " ?] "),Prompt);
 281       if (AnalPrompt(question, Prompt) == false)
 282       {
 283          c2out << _("Abort.") << std::endl;
 284          exit(1);
 285       }
 286    }
 287    else
 288    {
 289       // Prompt to continue
 290       if (Ask == true || Fail == true)
 291       {
 292          if (_config->FindB("APT::Get::Trivial-Only",false) == true)
 293             return _error->Error(_("Trivial Only specified but this is not a trivial operation."));
 294
 295          if (_config->FindI("quiet",0) < 2 &&
 296              _config->FindB("APT::Get::Assume-Yes",false) == false)
 297          {
 298             if (YnPrompt(_("Do you want to continue?")) == false)
 299             {
 300                c2out << _("Abort.") << std::endl;
 301                exit(1);
 302             }
 303          }
 304       }
 305    }
 306
 307    if (!CheckAuth(Fetcher, true))
 308       return false;
 309
 310    /* Unlock the dpkg lock if we are not going to be doing an install
 311       after. */
 312    if (_config->FindB("APT::Get::Download-Only",false) == true)
 313       _system->UnLock();
 314
 315    // Run it
 316    bool Failed = false;
 317    while (1)
 318    {
 319       bool Transient = false;
 320       if (AcquireRun(Fetcher, 0, &Failed, &Transient) == false)
 321          return false;
 322
 323       if (_config->FindB("APT::Get::Download-Only",false) == true)
 324       {
 325          if (Failed == true && _config->FindB("APT::Get::Fix-Missing",false) == false)
 326             return _error->Error(_("Some files failed to download"));
 327          c1out << _("Download complete and in download only mode") << std::endl;
 328          return true;
 329       }
 330
 331       if (Failed == true && _config->FindB("APT::Get::Fix-Missing",false) == false)
 332          return _error->Error(_("Unable to fetch some archives, maybe run apt-get update or try with --fix-missing?"));
 333
 334       if (Transient == true && Failed == true)
 335          return _error->Error(_("--fix-missing and media swapping is not currently supported"));
 336
 337       // Try to deal with missing package files
 338       if (Failed == true && PM->FixMissing() == false)
 339       {
 340          c2out << _("Unable to correct missing packages.") << std::endl;
 341          return _error->Error(_("Aborting install."));
 342       }
 343
 344       auto const progress = APT::Progress::PackageManagerProgressFactory();
 345       _system->UnLock();
 346       pkgPackageManager::OrderResult const Res = PM->DoInstall(progress);
 347       delete progress;
 348
 349       if (Res == pkgPackageManager::Failed || _error->PendingError() == true)
 350          return false;
 351       if (Res == pkgPackageManager::Completed)
 352          break;
 353
 354       _system->Lock();
 355
 356       // Reload the fetcher object and loop again for media swapping
 357       Fetcher.Shutdown();
 358       if (PM->GetArchives(&Fetcher,List,&Recs) == false)
 359          return false;
 360
 361       Failed = false;
 362       if (_config->FindB("APT::Get::Download",true) == false)
 363          RemoveDownloadNeedingItemsFromFetcher(Fetcher, Failed);
 364    }
 365
 366    std::set<std::string> const disappearedPkgs = PM->GetDisappearedPackages();
 367    if (disappearedPkgs.empty() == false)
 368    {
 369       ShowList(c1out, P_("The following package disappeared from your system as\n"
 370                "all files have been overwritten by other packages:",
 371                "The following packages disappeared from your system as\n"
 372                "all files have been overwritten by other packages:", disappearedPkgs.size()), disappearedPkgs,
 373             [](std::string const &Pkg) { return Pkg.empty() == false; },
 374             [](std::string const &Pkg) { return Pkg; },
 375             [](std::string const &) { return std::string(); });
 376       c0out << _("Note: This is done automatically and on purpose by dpkg.") << std::endl;
 377    }
 378
 379    // cleanup downloaded debs
 380    if (_config->FindB("APT::Keep-Downloaded-Packages", true) == false)
 381    {
 382       std::string const archivedir = _config->FindDir("Dir::Cache::archives");
 383       for (auto I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); ++I)
 384       {
 385          if (flNotFile((*I)->DestFile) != archivedir || (*I)->Local)
 386             continue;
 387          RemoveFile("Keep-Downloaded-Packages=false", (*I)->DestFile);
 388       }
 389    }
 390
 391    return true;
 392 }
 393                                                                         /*}}}*/
 394 // DoAutomaticRemove - Remove all automatic unused packages             /*{{{*/
 395 // ---------------------------------------------------------------------
 396 /* Remove unused automatic packages */
 397 bool DoAutomaticRemove(CacheFile &Cache)
 398 {
 399    bool Debug = _config->FindI("Debug::pkgAutoRemove",false);
 400    bool doAutoRemove = _config->FindB("APT::Get::AutomaticRemove", false);
 401    bool hideAutoRemove = _config->FindB("APT::Get::HideAutoRemove");
 402
 403    pkgDepCache::ActionGroup group(*Cache);
 404    if(Debug)
 405       std::cout << "DoAutomaticRemove()" << std::endl;
 406
 407    if (doAutoRemove == true &&
 408         _config->FindB("APT::Get::Remove",true) == false)
 409    {
 410       c1out << _("We are not supposed to delete stuff, can't start "
 411                  "AutoRemover") << std::endl;
 412       return false;
 413    }
 414
 415    bool purgePkgs = _config->FindB("APT::Get::Purge", false);
 416    bool smallList = (hideAutoRemove == false &&
 417                 strcasecmp(_config->Find("APT::Get::HideAutoRemove","").c_str(),"small") == 0);
 418
 419    unsigned long autoRemoveCount = 0;
 420    APT::PackageSet tooMuch;
 421    SortedPackageUniverse Universe(Cache);
 422    // look over the cache to see what can be removed
 423    for (auto const &Pkg: Universe)
 424    {
 425       if (Cache[Pkg].Garbage)
 426       {
 427          if(Pkg.CurrentVer() != 0 || Cache[Pkg].Install())
 428             if(Debug)
 429                std::cout << "We could delete " <<  APT::PrettyPkg(Cache, Pkg) << std::endl;
 430
 431          if (doAutoRemove)
 432          {
 433             if(Pkg.CurrentVer() != 0 &&
 434                Pkg->CurrentState != pkgCache::State::ConfigFiles)
 435                Cache->MarkDelete(Pkg, purgePkgs, 0, false);
 436             else
 437                Cache->MarkKeep(Pkg, false, false);
 438          }
 439          else
 440          {
 441             // if the package is a new install and already garbage we don't need to
 442             // install it in the first place, so nuke it instead of show it
 443             if (Cache[Pkg].Install() == true && Pkg.CurrentVer() == 0)
 444             {
 445                tooMuch.insert(Pkg);
 446                Cache->MarkDelete(Pkg, false, 0, false);
 447             }
 448             // only show stuff in the list that is not yet marked for removal
 449             else if(hideAutoRemove == false && Cache[Pkg].Delete() == false)
 450                ++autoRemoveCount;
 451          }
 452       }
 453    }
 454
 455    // we could have removed a new dependency of a garbage package,
 456    // so check if a reverse depends is broken and if so install it again.
 457    if (tooMuch.empty() == false && (Cache->BrokenCount() != 0 || Cache->PolicyBrokenCount() != 0))
 458    {
 459       bool Changed;
 460       do {
 461          Changed = false;
 462          for (APT::PackageSet::iterator Pkg = tooMuch.begin();
 463               Pkg != tooMuch.end(); ++Pkg)
 464          {
 465             APT::PackageSet too;
 466             too.insert(*Pkg);
 467             for (pkgCache::PrvIterator Prv = Cache[Pkg].CandidateVerIter(Cache).ProvidesList();
 468                  Prv.end() == false; ++Prv)
 469                too.insert(Prv.ParentPkg());
 470             for (APT::PackageSet::const_iterator P = too.begin(); P != too.end(); ++P)
 471             {
 472                for (pkgCache::DepIterator R = P.RevDependsList();
 473                     R.end() == false; ++R)
 474                {
 475                   if (R.IsNegative() == true ||
 476                       Cache->IsImportantDep(R) == false)
 477                      continue;
 478                  auto const RV = R.ParentVer();
 479                  if (unlikely(RV.end() == true))
 480                     continue;
 481                  auto const RP = RV.ParentPkg();
 482                  // check if that dependency comes from an interesting version
 483                  if (RP.CurrentVer() == RV)
 484                  {
 485                     if ((*Cache)[RP].Keep() == false)
 486                        continue;
 487                  }
 488                  else if (Cache[RP].CandidateVerIter(Cache) == RV)
 489                  {
 490                     if ((*Cache)[RP].NewInstall() == false && (*Cache)[RP].Upgrade() == false)
 491                        continue;
 492                  }
 493                  else // ignore dependency from a non-candidate version
 494                     continue;
 495                  if (Debug == true)
 496                     std::clog << "Save " << APT::PrettyPkg(Cache, Pkg) << " as another installed package depends on it: " << APT::PrettyPkg(Cache, RP) << std::endl;
 497                  Cache->MarkInstall(Pkg, false, 0, false);
 498                  if (hideAutoRemove == false)
 499                     ++autoRemoveCount;
 500                  tooMuch.erase(Pkg);
 501                  Changed = true;
 502                  break;
 503                }
 504                if (Changed == true)
 505                   break;
 506             }
 507             if (Changed == true)
 508                break;
 509          }
 510       } while (Changed == true);
 511    }
 512    // trigger marking now so that the package list below is correct
 513    group.release();
 514
 515    // Now see if we had destroyed anything (if we had done anything)
 516    if (Cache->BrokenCount() != 0)
 517    {
 518       c1out << _("Hmm, seems like the AutoRemover destroyed something which really\n"
 519                  "shouldn't happen. Please file a bug report against apt.") << std::endl;
 520       c1out << std::endl;
 521       c1out << _("The following information may help to resolve the situation:") << std::endl;
 522       c1out << std::endl;
 523       ShowBroken(c1out,Cache,false);
 524
 525       return _error->Error(_("Internal Error, AutoRemover broke stuff"));
 526    }
 527
 528    // if we don't remove them, we should show them!
 529    if (doAutoRemove == false && autoRemoveCount != 0)
 530    {
 531       if (smallList == false)
 532       {
 533          SortedPackageUniverse Universe(Cache);
 534          ShowList(c1out, P_("The following package was automatically installed and is no longer required:",
 535                   "The following packages were automatically installed and are no longer required:",
 536                   autoRemoveCount), Universe,
 537                [&Cache](pkgCache::PkgIterator const &Pkg) { return (*Cache)[Pkg].Garbage == true && (*Cache)[Pkg].Delete() == false; },
 538                &PrettyFullName, CandidateVersion(&Cache));
 539       }
 540       else
 541          ioprintf(c1out, P_("%lu package was automatically installed and is no longer required.\n",
 542                   "%lu packages were automatically installed and are no longer required.\n", autoRemoveCount), autoRemoveCount);
 543       std::string autocmd = "apt autoremove";
 544       if (getenv("SUDO_USER") != nullptr)
 545       {
 546          auto const envsudocmd = getenv("SUDO_COMMAND");
 547          auto const envshell = getenv("SHELL");
 548          if (envsudocmd == nullptr || envshell == nullptr || strcmp(envsudocmd, envshell) != 0)
 549             autocmd = "sudo " + autocmd;
 550       }
 551       ioprintf(c1out, P_("Use '%s' to remove it.", "Use '%s' to remove them.", autoRemoveCount), autocmd.c_str());
 552       c1out << std::endl;
 553    }
 554    return true;
 555 }
 556                                                                         /*}}}*/
 557 // DoCacheManipulationFromCommandLine                                   /*{{{*/
 558 static const unsigned short MOD_REMOVE = 1;
 559 static const unsigned short MOD_INSTALL = 2;
 560
 561 bool DoCacheManipulationFromCommandLine(CommandLine &CmdL, CacheFile &Cache, int UpgradeMode)
 562 {
 563    std::vector<std::string> VolatileCmdL;
 564    return DoCacheManipulationFromCommandLine(CmdL, VolatileCmdL, Cache, UpgradeMode);
 565 }
 566 bool DoCacheManipulationFromCommandLine(CommandLine &CmdL, std::vector<std::string> &VolatileCmdL, CacheFile &Cache, int UpgradeMode)
 567 {
 568    std::map<unsigned short, APT::VersionSet> verset;
 569    return DoCacheManipulationFromCommandLine(CmdL, VolatileCmdL, Cache, verset, UpgradeMode);
 570 }
 571 bool DoCacheManipulationFromCommandLine(CommandLine &CmdL, std::vector<std::string> &VolatileCmdL, CacheFile &Cache,
 572                                         std::map<unsigned short, APT::VersionSet> &verset, int UpgradeMode)
 573 {
 574    // Enter the special broken fixing mode if the user specified arguments
 575    bool BrokenFix = false;
 576    if (Cache->BrokenCount() != 0)
 577       BrokenFix = true;
 578
 579    std::unique_ptr<pkgProblemResolver> Fix(nullptr);
 580    if (_config->FindB("APT::Get::CallResolver", true) == true)
 581       Fix.reset(new pkgProblemResolver(Cache));
 582
 583    unsigned short fallback = MOD_INSTALL;
 584    if (strcasecmp(CmdL.FileList[0],"remove") == 0)
 585       fallback = MOD_REMOVE;
 586    else if (strcasecmp(CmdL.FileList[0], "purge") == 0)
 587    {
 588       _config->Set("APT::Get::Purge", true);
 589       fallback = MOD_REMOVE;
 590    }
 591    else if (strcasecmp(CmdL.FileList[0], "autoremove") == 0 ||
 592             strcasecmp(CmdL.FileList[0], "auto-remove") == 0)
 593    {
 594       _config->Set("APT::Get::AutomaticRemove", "true");
 595       fallback = MOD_REMOVE;
 596    }
 597
 598    std::list<APT::VersionSet::Modifier> mods;
 599    mods.push_back(APT::VersionSet::Modifier(MOD_INSTALL, "+",
 600                 APT::VersionSet::Modifier::POSTFIX, APT::CacheSetHelper::CANDIDATE));
 601    mods.push_back(APT::VersionSet::Modifier(MOD_REMOVE, "-",
 602                 APT::VersionSet::Modifier::POSTFIX, APT::CacheSetHelper::NEWEST));
 603    CacheSetHelperAPTGet helper(c0out);
 604    verset = APT::VersionSet::GroupedFromCommandLine(Cache,
 605                 CmdL.FileList + 1, mods, fallback, helper);
 606
 607    for (auto const &I: VolatileCmdL)
 608    {
 609       pkgCache::PkgIterator const P = Cache->FindPkg(I);
 610       if (P.end())
 611          continue;
 612
 613       // Set any version providing the .deb as the candidate.
 614       for (auto Prv = P.ProvidesList(); Prv.end() == false; Prv++)
 615          Cache.GetDepCache()->SetCandidateVersion(Prv.OwnerVer());
 616
 617       // via cacheset to have our usual virtual handling
 618       APT::VersionContainerInterface::FromPackage(&(verset[MOD_INSTALL]), Cache, P, APT::CacheSetHelper::CANDIDATE, helper);
 619    }
 620
 621    if (_error->PendingError() == true)
 622    {
 623       helper.showVirtualPackageErrors(Cache);
 624       return false;
 625    }
 626
 627
 628   TryToInstall InstallAction(Cache, Fix.get(), BrokenFix);
 629   TryToRemove RemoveAction(Cache, Fix.get());
 630
 631    // new scope for the ActionGroup
 632    {
 633       pkgDepCache::ActionGroup group(Cache);
 634       unsigned short const order[] = { MOD_REMOVE, MOD_INSTALL, 0 };
 635
 636       for (unsigned short i = 0; order[i] != 0; ++i)
 637       {
 638          if (order[i] == MOD_INSTALL)
 639             InstallAction = std::for_each(verset[MOD_INSTALL].begin(), verset[MOD_INSTALL].end(), InstallAction);
 640          else if (order[i] == MOD_REMOVE)
 641             RemoveAction = std::for_each(verset[MOD_REMOVE].begin(), verset[MOD_REMOVE].end(), RemoveAction);
 642       }
 643
 644       if (Fix != NULL && _config->FindB("APT::Get::AutoSolving", true) == true)
 645       {
 646          InstallAction.propergateReleaseCandiateSwitching(helper.selectedByRelease, c0out);
 647          InstallAction.doAutoInstall();
 648       }
 649
 650       if (_error->PendingError() == true)
 651       {
 652          return false;
 653       }
 654
 655       /* If we are in the Broken fixing mode we do not attempt to fix the
 656          problems. This is if the user invoked install without -f and gave
 657          packages */
 658       if (BrokenFix == true && Cache->BrokenCount() != 0)
 659       {
 660          c1out << _("You might want to run 'apt-get -f install' to correct these:") << std::endl;
 661          ShowBroken(c1out,Cache,false);
 662          return _error->Error(_("Unmet dependencies. Try 'apt-get -f install' with no packages (or specify a solution)."));
 663       }
 664
 665       if (Fix != NULL)
 666       {
 667          // Call the scored problem resolver
 668          OpTextProgress Progress(*_config);
 669          bool const distUpgradeMode = strcmp(CmdL.FileList[0], "dist-upgrade") == 0 || strcmp(CmdL.FileList[0], "full-upgrade") == 0;
 670
 671          bool resolver_fail = false;
 672          if (distUpgradeMode == true || UpgradeMode != APT::Upgrade::ALLOW_EVERYTHING)
 673             resolver_fail = APT::Upgrade::Upgrade(Cache, UpgradeMode, &Progress);
 674          else
 675             resolver_fail = Fix->Resolve(true, &Progress);
 676
 677          if (resolver_fail == false && Cache->BrokenCount() == 0)
 678             return false;
 679       }
 680
 681       if (CheckNothingBroken(Cache) == false)
 682          return false;
 683    }
 684    if (!DoAutomaticRemove(Cache))
 685       return false;
 686
 687    // if nothing changed in the cache, but only the automark information
 688    // we write the StateFile here, otherwise it will be written in
 689    // cache.commit()
 690    if (InstallAction.AutoMarkChanged > 0 &&
 691        Cache->DelCount() == 0 && Cache->InstCount() == 0 &&
 692        Cache->BadCount() == 0 &&
 693        _config->FindB("APT::Get::Simulate",false) == false)
 694       Cache->writeStateFile(NULL);
 695
 696    return true;
 697 }
 698                                                                         /*}}}*/
 699 // DoInstall - Install packages from the command line                   /*{{{*/
 700 // ---------------------------------------------------------------------
 701 /* Install named packages */
 702 struct PkgIsExtraInstalled {
 703    pkgCacheFile * const Cache;
 704    APT::VersionSet const * const verset;
 705    PkgIsExtraInstalled(pkgCacheFile * const Cache, APT::VersionSet const * const Container) : Cache(Cache), verset(Container) {}
 706    bool operator() (pkgCache::PkgIterator const &Pkg)
 707    {
 708         if ((*Cache)[Pkg].Install() == false)
 709            return false;
 710         pkgCache::VerIterator const Cand = (*Cache)[Pkg].CandidateVerIter(*Cache);
 711         return verset->find(Cand) == verset->end();
 712    }
 713 };
 714 bool DoInstall(CommandLine &CmdL)
 715 {
 716    CacheFile Cache;
 717    std::vector<std::string> VolatileCmdL;
 718    Cache.GetSourceList()->AddVolatileFiles(CmdL, &VolatileCmdL);
 719
 720    // then open the cache
 721    if (Cache.OpenForInstall() == false ||
 722        Cache.CheckDeps(CmdL.FileSize() != 1) == false)
 723       return false;
 724
 725    std::map<unsigned short, APT::VersionSet> verset;
 726    if(!DoCacheManipulationFromCommandLine(CmdL, VolatileCmdL, Cache, verset, 0))
 727       return false;
 728
 729    /* Print out a list of packages that are going to be installed extra
 730       to what the user asked */
 731    SortedPackageUniverse Universe(Cache);
 732    if (Cache->InstCount() != verset[MOD_INSTALL].size())
 733       ShowList(c1out, _("The following additional packages will be installed:"), Universe,
 734             PkgIsExtraInstalled(&Cache, &verset[MOD_INSTALL]),
 735             &PrettyFullName, CandidateVersion(&Cache));
 736
 737    /* Print out a list of suggested and recommended packages */
 738    {
 739       std::list<std::string> Recommends, Suggests, SingleRecommends, SingleSuggests;
 740       for (auto const &Pkg: Universe)
 741       {
 742          /* Just look at the ones we want to install */
 743          if ((*Cache)[Pkg].Install() == false)
 744            continue;
 745
 746          // get the recommends/suggests for the candidate ver
 747          pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
 748          for (pkgCache::DepIterator D = CV.DependsList(); D.end() == false; )
 749          {
 750             pkgCache::DepIterator Start;
 751             pkgCache::DepIterator End;
 752             D.GlobOr(Start,End); // advances D
 753             if (Start->Type != pkgCache::Dep::Recommends && Start->Type != pkgCache::Dep::Suggests)
 754                continue;
 755
 756             {
 757                // Skip if we already saw this
 758                std::string target;
 759                for (pkgCache::DepIterator I = Start; I != D; ++I)
 760                {
 761                   if (target.empty() == false)
 762                      target.append(" | ");
 763                   target.append(I.TargetPkg().FullName(true));
 764                }
 765                std::list<std::string> &Type = Start->Type == pkgCache::Dep::Recommends ? SingleRecommends : SingleSuggests;
 766                if (std::find(Type.begin(), Type.end(), target) != Type.end())
 767                   continue;
 768                Type.push_back(target);
 769             }
 770
 771             std::list<std::string> OrList;
 772             bool foundInstalledInOrGroup = false;
 773             for (pkgCache::DepIterator I = Start; I != D; ++I)
 774             {
 775                {
 776                   // satisfying package is installed and not marked for deletion
 777                   APT::VersionList installed = APT::VersionList::FromDependency(Cache, I, APT::CacheSetHelper::INSTALLED);
 778                   if (std::find_if(installed.begin(), installed.end(),
 779                            [&Cache](pkgCache::VerIterator const &Ver) { return Cache[Ver.ParentPkg()].Delete() == false; }) != installed.end())
 780                   {
 781                      foundInstalledInOrGroup = true;
 782                      break;
 783                   }
 784                }
 785
 786                {
 787                   // satisfying package is upgraded to/new install
 788                   APT::VersionList upgrades = APT::VersionList::FromDependency(Cache, I, APT::CacheSetHelper::CANDIDATE);
 789                   if (std::find_if(upgrades.begin(), upgrades.end(),
 790                            [&Cache](pkgCache::VerIterator const &Ver) { return Cache[Ver.ParentPkg()].Upgrade(); }) != upgrades.end())
 791                   {
 792                      foundInstalledInOrGroup = true;
 793                      break;
 794                   }
 795                }
 796
 797                if (OrList.empty())
 798                   OrList.push_back(I.TargetPkg().FullName(true));
 799                else
 800                   OrList.push_back("| " + I.TargetPkg().FullName(true));
 801             }
 802
 803             if(foundInstalledInOrGroup == false)
 804             {
 805                std::list<std::string> &Type = Start->Type == pkgCache::Dep::Recommends ? Recommends : Suggests;
 806                std::move(OrList.begin(), OrList.end(), std::back_inserter(Type));
 807             }
 808          }
 809       }
 810       auto always_true = [](std::string const&) { return true; };
 811       auto string_ident = [](std::string const&str) { return str; };
 812       auto verbose_show_candidate =
 813          [&Cache](std::string str)
 814          {
 815             if (APT::String::Startswith(str, "| "))
 816                str.erase(0, 2);
 817             pkgCache::PkgIterator const Pkg = Cache->FindPkg(str);
 818             if (Pkg.end() == true)
 819                return "";
 820             return (*Cache)[Pkg].CandVersion;
 821          };
 822       ShowList(c1out,_("Suggested packages:"), Suggests,
 823             always_true, string_ident, verbose_show_candidate);
 824       ShowList(c1out,_("Recommended packages:"), Recommends,
 825             always_true, string_ident, verbose_show_candidate);
 826    }
 827
 828    // See if we need to prompt
 829    // FIXME: check if really the packages in the set are going to be installed
 830    if (Cache->InstCount() == verset[MOD_INSTALL].size() && Cache->DelCount() == 0)
 831       return InstallPackages(Cache,false,false);
 832
 833    return InstallPackages(Cache,false);
 834 }
 835                                                                         /*}}}*/
 836
 837 // TryToInstall - Mark a package for installation                       /*{{{*/
 838 void TryToInstall::operator() (pkgCache::VerIterator const &Ver) {
 839    if (unlikely(Ver.end()))
 840    {
 841       _error->Fatal("The given version to TryToInstall is invalid!");
 842       return;
 843    }
 844    pkgCache::PkgIterator Pkg = Ver.ParentPkg();
 845    if (unlikely(Pkg.end()))
 846    {
 847       _error->Fatal("The given version to TryToInstall has an invalid parent package!");
 848       return;
 849    }
 850
 851    Cache->GetDepCache()->SetCandidateVersion(Ver);
 852    pkgDepCache::StateCache &State = (*Cache)[Pkg];
 853
 854    // Handle the no-upgrade case
 855    if (_config->FindB("APT::Get::upgrade",true) == false && Pkg->CurrentVer != 0)
 856       ioprintf(c1out,_("Skipping %s, it is already installed and upgrade is not set.\n"),
 857             Pkg.FullName(true).c_str());
 858    // Ignore request for install if package would be new
 859    else if (_config->FindB("APT::Get::Only-Upgrade", false) == true && Pkg->CurrentVer == 0)
 860       ioprintf(c1out,_("Skipping %s, it is not installed and only upgrades are requested.\n"),
 861             Pkg.FullName(true).c_str());
 862    else {
 863       if (Fix != NULL) {
 864          Fix->Clear(Pkg);
 865          Fix->Protect(Pkg);
 866       }
 867       Cache->GetDepCache()->MarkInstall(Pkg,false);
 868
 869       if (State.Install() == false) {
 870          if (_config->FindB("APT::Get::ReInstall",false) == true) {
 871             if (Pkg->CurrentVer == 0 || Pkg.CurrentVer().Downloadable() == false)
 872                ioprintf(c1out,_("Reinstallation of %s is not possible, it cannot be downloaded.\n"),
 873                      Pkg.FullName(true).c_str());
 874             else
 875                Cache->GetDepCache()->SetReInstall(Pkg, true);
 876          } else
 877             // TRANSLATORS: First string is package name, second is version
 878             ioprintf(c1out,_("%s is already the newest version (%s).\n"),
 879                   Pkg.FullName(true).c_str(), Pkg.CurrentVer().VerStr());
 880       }
 881
 882       // Install it with autoinstalling enabled (if we not respect the minial
 883       // required deps or the policy)
 884       if (FixBroken == false)
 885          doAutoInstallLater.insert(Pkg);
 886    }
 887
 888    // see if we need to fix the auto-mark flag
 889    // e.g. apt-get install foo
 890    // where foo is marked automatic
 891    if (State.Install() == false &&
 892          (State.Flags & pkgCache::Flag::Auto) &&
 893          _config->FindB("APT::Get::ReInstall",false) == false &&
 894          _config->FindB("APT::Get::Only-Upgrade",false) == false &&
 895          _config->FindB("APT::Get::Download-Only",false) == false)
 896    {
 897       ioprintf(c1out,_("%s set to manually installed.\n"),
 898             Pkg.FullName(true).c_str());
 899       Cache->GetDepCache()->MarkAuto(Pkg,false);
 900       AutoMarkChanged++;
 901    }
 902 }
 903                                                                         /*}}}*/
 904 bool TryToInstall::propergateReleaseCandiateSwitching(std::list<std::pair<pkgCache::VerIterator, std::string> > const &start, std::ostream &out)/*{{{*/
 905 {
 906    for (std::list<std::pair<pkgCache::VerIterator, std::string> >::const_iterator s = start.begin();
 907          s != start.end(); ++s)
 908       Cache->GetDepCache()->SetCandidateVersion(s->first);
 909
 910    bool Success = true;
 911    // the Changed list contains:
 912    //   first: "new version"
 913    //   second: "what-caused the change"
 914    std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> > Changed;
 915    for (std::list<std::pair<pkgCache::VerIterator, std::string> >::const_iterator s = start.begin();
 916          s != start.end(); ++s)
 917    {
 918       Changed.push_back(std::make_pair(s->first, pkgCache::VerIterator(*Cache)));
 919       // We continue here even if it failed to enhance the ShowBroken output
 920       Success &= Cache->GetDepCache()->SetCandidateRelease(s->first, s->second, Changed);
 921    }
 922    for (std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> >::const_iterator c = Changed.begin();
 923          c != Changed.end(); ++c)
 924    {
 925       if (c->second.end() == true)
 926          ioprintf(out, _("Selected version '%s' (%s) for '%s'\n"),
 927                c->first.VerStr(), c->first.RelStr().c_str(), c->first.ParentPkg().FullName(true).c_str());
 928       else if (c->first.ParentPkg()->Group != c->second.ParentPkg()->Group)
 929       {
 930          pkgCache::VerIterator V = (*Cache)[c->first.ParentPkg()].CandidateVerIter(*Cache);
 931          ioprintf(out, _("Selected version '%s' (%s) for '%s' because of '%s'\n"), V.VerStr(),
 932                V.RelStr().c_str(), V.ParentPkg().FullName(true).c_str(), c->second.ParentPkg().FullName(true).c_str());
 933       }
 934    }
 935    return Success;
 936 }
 937                                                                         /*}}}*/
 938 void TryToInstall::doAutoInstall() {                                    /*{{{*/
 939    for (APT::PackageSet::const_iterator P = doAutoInstallLater.begin();
 940          P != doAutoInstallLater.end(); ++P) {
 941       pkgDepCache::StateCache &State = (*Cache)[P];
 942       if (State.InstBroken() == false && State.InstPolicyBroken() == false)
 943          continue;
 944       Cache->GetDepCache()->MarkInstall(P, true);
 945    }
 946    doAutoInstallLater.clear();
 947 }
 948                                                                         /*}}}*/
 949 // TryToRemove - Mark a package for removal                             /*{{{*/
 950 void TryToRemove::operator() (pkgCache::VerIterator const &Ver)
 951 {
 952    pkgCache::PkgIterator Pkg = Ver.ParentPkg();
 953
 954    if (Fix != NULL)
 955    {
 956       Fix->Clear(Pkg);
 957       Fix->Protect(Pkg);
 958       Fix->Remove(Pkg);
 959    }
 960
 961    if ((Pkg->CurrentVer == 0 && PurgePkgs == false) ||
 962          (PurgePkgs == true && Pkg->CurrentState == pkgCache::State::NotInstalled))
 963    {
 964       pkgCache::GrpIterator Grp = Pkg.Group();
 965       pkgCache::PkgIterator P = Grp.PackageList();
 966       for (; P.end() != true; P = Grp.NextPkg(P))
 967       {
 968          if (P == Pkg)
 969             continue;
 970          if (P->CurrentVer != 0 || (PurgePkgs == true && P->CurrentState != pkgCache::State::NotInstalled))
 971          {
 972             // TRANSLATORS: Note, this is not an interactive question
 973             ioprintf(c1out,_("Package '%s' is not installed, so not removed. Did you mean '%s'?\n"),
 974                   Pkg.FullName(true).c_str(), P.FullName(true).c_str());
 975             break;
 976          }
 977       }
 978       if (P.end() == true)
 979          ioprintf(c1out,_("Package '%s' is not installed, so not removed\n"),Pkg.FullName(true).c_str());
 980
 981       // MarkInstall refuses to install packages on hold
 982       Pkg->SelectedState = pkgCache::State::Hold;
 983    }
 984    else
 985       Cache->GetDepCache()->MarkDelete(Pkg, PurgePkgs);
 986 }
 987                                                                         /*}}}*/