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