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