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::CacheSetHelper::CANDIDATE));
 564    mods.push_back(APT::VersionSet::Modifier(MOD_REMOVE, "-",
 565                 APT::VersionSet::Modifier::POSTFIX, APT::CacheSetHelper::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          OpTextProgress Progress(*_config);
 623          bool const distUpgradeMode = strcmp(CmdL.FileList[0], "dist-upgrade") == 0 || strcmp(CmdL.FileList[0], "full-upgrade") == 0;
 624
 625          bool resolver_fail = false;
 626          if (distUpgradeMode == true || UpgradeMode != APT::Upgrade::ALLOW_EVERYTHING)
 627             resolver_fail = APT::Upgrade::Upgrade(Cache, UpgradeMode, &Progress);
 628          else
 629             resolver_fail = Fix->Resolve(true, &Progress);
 630
 631          if (resolver_fail == false && Cache->BrokenCount() == 0)
 632             return false;
 633       }
 634
 635       // Now we check the state of the packages,
 636       if (Cache->BrokenCount() != 0)
 637       {
 638          c1out <<
 639             _("Some packages could not be installed. This may mean that you have\n"
 640               "requested an impossible situation or if you are using the unstable\n"
 641               "distribution that some required packages have not yet been created\n"
 642               "or been moved out of Incoming.") << std::endl;
 643          /*
 644          if (Packages == 1)
 645          {
 646             c1out << std::endl;
 647             c1out <<
 648                _("Since you only requested a single operation it is extremely likely that\n"
 649                  "the package is simply not installable and a bug report against\n"
 650                  "that package should be filed.") << std::endl;
 651          }
 652          */
 653
 654          c1out << _("The following information may help to resolve the situation:") << std::endl;
 655          c1out << std::endl;
 656          ShowBroken(c1out,Cache,false);
 657          if (_error->PendingError() == true)
 658             return false;
 659          else
 660             return _error->Error(_("Broken packages"));
 661       }
 662    }
 663    if (!DoAutomaticRemove(Cache))
 664       return false;
 665
 666    // if nothing changed in the cache, but only the automark information
 667    // we write the StateFile here, otherwise it will be written in
 668    // cache.commit()
 669    if (InstallAction.AutoMarkChanged > 0 &&
 670        Cache->DelCount() == 0 && Cache->InstCount() == 0 &&
 671        Cache->BadCount() == 0 &&
 672        _config->FindB("APT::Get::Simulate",false) == false)
 673       Cache->writeStateFile(NULL);
 674
 675    return true;
 676 }
 677                                                                         /*}}}*/
 678 // DoInstall - Install packages from the command line                   /*{{{*/
 679 // ---------------------------------------------------------------------
 680 /* Install named packages */
 681 bool DoInstall(CommandLine &CmdL)
 682 {
 683    CacheFile Cache;
 684    // first check for local pkgs and add them to the cache
 685    for (const char **I = CmdL.FileList; *I != 0; I++)
 686    {
 687       if(FileExists(*I))
 688       {
 689          // FIXME: make this more elegant
 690          std::string TypeStr = flExtension(*I) + "-file";
 691          pkgSourceList::Type *Type = pkgSourceList::Type::GetType(TypeStr.c_str());
 692          if(Type != 0)
 693          {
 694             std::vector<metaIndex *> List;
 695             std::map<std::string, std::string> Options;
 696             if(Type->CreateItem(List, *I, "", "", Options))
 697             {
 698                // we have our own CacheFile that gives us a SourceList
 699                // with superpowerz
 700                SourceList *sources = (SourceList*)Cache.GetSourceList();
 701                sources->AddMetaIndex(List[0]);
 702             }
 703          }
 704       }
 705    }
 706
 707    // then open the cache
 708    if (Cache.OpenForInstall() == false ||
 709        Cache.CheckDeps(CmdL.FileSize() != 1) == false)
 710       return false;
 711
 712    std::map<unsigned short, APT::VersionSet> verset;
 713
 714    if(!DoCacheManipulationFromCommandLine(CmdL, Cache, verset, 0))
 715       return false;
 716
 717    /* Print out a list of packages that are going to be installed extra
 718       to what the user asked */
 719    if (Cache->InstCount() != verset[MOD_INSTALL].size())
 720    {
 721       std::string List;
 722       std::string VersionsList;
 723       for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 724       {
 725          pkgCache::PkgIterator I(Cache,Cache.List[J]);
 726          if ((*Cache)[I].Install() == false)
 727             continue;
 728          pkgCache::VerIterator Cand = Cache[I].CandidateVerIter(Cache);
 729
 730          if (verset[MOD_INSTALL].find(Cand) != verset[MOD_INSTALL].end())
 731             continue;
 732
 733          List += I.FullName(true) + " ";
 734          VersionsList += std::string(Cache[I].CandVersion) + "\n";
 735       }
 736
 737       ShowList(c1out,_("The following extra packages will be installed:"),List,VersionsList);
 738    }
 739
 740    /* Print out a list of suggested and recommended packages */
 741    {
 742       std::string SuggestsList, RecommendsList;
 743       std::string SuggestsVersions, RecommendsVersions;
 744       for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 745       {
 746          pkgCache::PkgIterator Pkg(Cache,Cache.List[J]);
 747
 748          /* Just look at the ones we want to install */
 749          if ((*Cache)[Pkg].Install() == false)
 750            continue;
 751
 752          // get the recommends/suggests for the candidate ver
 753          pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
 754          for (pkgCache::DepIterator D = CV.DependsList(); D.end() == false; )
 755          {
 756             pkgCache::DepIterator Start;
 757             pkgCache::DepIterator End;
 758             D.GlobOr(Start,End); // advances D
 759
 760             // FIXME: we really should display a or-group as a or-group to the user
 761             //        the problem is that ShowList is incapable of doing this
 762             std::string RecommendsOrList,RecommendsOrVersions;
 763             std::string SuggestsOrList,SuggestsOrVersions;
 764             bool foundInstalledInOrGroup = false;
 765             for(;;)
 766             {
 767                /* Skip if package is  installed already, or is about to be */
 768                std::string target = Start.TargetPkg().FullName(true) + " ";
 769                pkgCache::PkgIterator const TarPkg = Start.TargetPkg();
 770                if (TarPkg->SelectedState == pkgCache::State::Install ||
 771                    TarPkg->SelectedState == pkgCache::State::Hold ||
 772                    Cache[Start.TargetPkg()].Install())
 773                {
 774                   foundInstalledInOrGroup=true;
 775                   break;
 776                }
 777
 778                /* Skip if we already saw it */
 779                if (int(SuggestsList.find(target)) != -1 || int(RecommendsList.find(target)) != -1)
 780                {
 781                   foundInstalledInOrGroup=true;
 782                   break;
 783                }
 784
 785                // this is a dep on a virtual pkg, check if any package that provides it
 786                // should be installed
 787                if(Start.TargetPkg().ProvidesList() != 0)
 788                {
 789                   pkgCache::PrvIterator I = Start.TargetPkg().ProvidesList();
 790                   for (; I.end() == false; ++I)
 791                   {
 792                      pkgCache::PkgIterator Pkg = I.OwnerPkg();
 793                      if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer() &&
 794                          Pkg.CurrentVer() != 0)
 795                         foundInstalledInOrGroup=true;
 796                   }
 797                }
 798
 799                if (Start->Type == pkgCache::Dep::Suggests)
 800                {
 801                   SuggestsOrList += target;
 802                   SuggestsOrVersions += std::string(Cache[Start.TargetPkg()].CandVersion) + "\n";
 803                }
 804
 805                if (Start->Type == pkgCache::Dep::Recommends)
 806                {
 807                   RecommendsOrList += target;
 808                   RecommendsOrVersions += std::string(Cache[Start.TargetPkg()].CandVersion) + "\n";
 809                }
 810
 811                if (Start >= End)
 812                   break;
 813                ++Start;
 814             }
 815
 816             if(foundInstalledInOrGroup == false)
 817             {
 818                RecommendsList += RecommendsOrList;
 819                RecommendsVersions += RecommendsOrVersions;
 820                SuggestsList += SuggestsOrList;
 821                SuggestsVersions += SuggestsOrVersions;
 822             }
 823
 824          }
 825       }
 826
 827       ShowList(c1out,_("Suggested packages:"),SuggestsList,SuggestsVersions);
 828       ShowList(c1out,_("Recommended packages:"),RecommendsList,RecommendsVersions);
 829
 830    }
 831
 832    // See if we need to prompt
 833    // FIXME: check if really the packages in the set are going to be installed
 834    if (Cache->InstCount() == verset[MOD_INSTALL].size() && Cache->DelCount() == 0)
 835       return InstallPackages(Cache,false,false);
 836
 837    return InstallPackages(Cache,false);
 838 }
 839                                                                         /*}}}*/
 840
 841 // TryToInstall - Mark a package for installation                       /*{{{*/
 842 void TryToInstall::operator() (pkgCache::VerIterator const &Ver) {
 843    pkgCache::PkgIterator Pkg = Ver.ParentPkg();
 844
 845    Cache->GetDepCache()->SetCandidateVersion(Ver);
 846    pkgDepCache::StateCache &State = (*Cache)[Pkg];
 847
 848    // Handle the no-upgrade case
 849    if (_config->FindB("APT::Get::upgrade",true) == false && Pkg->CurrentVer != 0)
 850       ioprintf(c1out,_("Skipping %s, it is already installed and upgrade is not set.\n"),
 851             Pkg.FullName(true).c_str());
 852    // Ignore request for install if package would be new
 853    else if (_config->FindB("APT::Get::Only-Upgrade", false) == true && Pkg->CurrentVer == 0)
 854       ioprintf(c1out,_("Skipping %s, it is not installed and only upgrades are requested.\n"),
 855             Pkg.FullName(true).c_str());
 856    else {
 857       if (Fix != NULL) {
 858          Fix->Clear(Pkg);
 859          Fix->Protect(Pkg);
 860       }
 861       Cache->GetDepCache()->MarkInstall(Pkg,false);
 862
 863       if (State.Install() == false) {
 864          if (_config->FindB("APT::Get::ReInstall",false) == true) {
 865             if (Pkg->CurrentVer == 0 || Pkg.CurrentVer().Downloadable() == false)
 866                ioprintf(c1out,_("Reinstallation of %s is not possible, it cannot be downloaded.\n"),
 867                      Pkg.FullName(true).c_str());
 868             else
 869                Cache->GetDepCache()->SetReInstall(Pkg, true);
 870          } else
 871             ioprintf(c1out,_("%s is already the newest version.\n"),
 872                   Pkg.FullName(true).c_str());
 873       }
 874
 875       // Install it with autoinstalling enabled (if we not respect the minial
 876       // required deps or the policy)
 877       if (FixBroken == false)
 878          doAutoInstallLater.insert(Pkg);
 879    }
 880
 881    // see if we need to fix the auto-mark flag
 882    // e.g. apt-get install foo
 883    // where foo is marked automatic
 884    if (State.Install() == false &&
 885          (State.Flags & pkgCache::Flag::Auto) &&
 886          _config->FindB("APT::Get::ReInstall",false) == false &&
 887          _config->FindB("APT::Get::Only-Upgrade",false) == false &&
 888          _config->FindB("APT::Get::Download-Only",false) == false)
 889    {
 890       ioprintf(c1out,_("%s set to manually installed.\n"),
 891             Pkg.FullName(true).c_str());
 892       Cache->GetDepCache()->MarkAuto(Pkg,false);
 893       AutoMarkChanged++;
 894    }
 895 }
 896                                                                         /*}}}*/
 897 bool TryToInstall::propergateReleaseCandiateSwitching(std::list<std::pair<pkgCache::VerIterator, std::string> > const &start, std::ostream &out)/*{{{*/
 898 {
 899    for (std::list<std::pair<pkgCache::VerIterator, std::string> >::const_iterator s = start.begin();
 900          s != start.end(); ++s)
 901       Cache->GetDepCache()->SetCandidateVersion(s->first);
 902
 903    bool Success = true;
 904    // the Changed list contains:
 905    //   first: "new version"
 906    //   second: "what-caused the change"
 907    std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> > Changed;
 908    for (std::list<std::pair<pkgCache::VerIterator, std::string> >::const_iterator s = start.begin();
 909          s != start.end(); ++s)
 910    {
 911       Changed.push_back(std::make_pair(s->first, pkgCache::VerIterator(*Cache)));
 912       // We continue here even if it failed to enhance the ShowBroken output
 913       Success &= Cache->GetDepCache()->SetCandidateRelease(s->first, s->second, Changed);
 914    }
 915    for (std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> >::const_iterator c = Changed.begin();
 916          c != Changed.end(); ++c)
 917    {
 918       if (c->second.end() == true)
 919          ioprintf(out, _("Selected version '%s' (%s) for '%s'\n"),
 920                c->first.VerStr(), c->first.RelStr().c_str(), c->first.ParentPkg().FullName(true).c_str());
 921       else if (c->first.ParentPkg()->Group != c->second.ParentPkg()->Group)
 922       {
 923          pkgCache::VerIterator V = (*Cache)[c->first.ParentPkg()].CandidateVerIter(*Cache);
 924          ioprintf(out, _("Selected version '%s' (%s) for '%s' because of '%s'\n"), V.VerStr(),
 925                V.RelStr().c_str(), V.ParentPkg().FullName(true).c_str(), c->second.ParentPkg().FullName(true).c_str());
 926       }
 927    }
 928    return Success;
 929 }
 930                                                                         /*}}}*/
 931 void TryToInstall::doAutoInstall() {                                    /*{{{*/
 932    for (APT::PackageSet::const_iterator P = doAutoInstallLater.begin();
 933          P != doAutoInstallLater.end(); ++P) {
 934       pkgDepCache::StateCache &State = (*Cache)[P];
 935       if (State.InstBroken() == false && State.InstPolicyBroken() == false)
 936          continue;
 937       Cache->GetDepCache()->MarkInstall(P, true);
 938    }
 939    doAutoInstallLater.clear();
 940 }
 941                                                                         /*}}}*/
 942 // TryToRemove - Mark a package for removal                             /*{{{*/
 943 void TryToRemove::operator() (pkgCache::VerIterator const &Ver)
 944 {
 945    pkgCache::PkgIterator Pkg = Ver.ParentPkg();
 946
 947    if (Fix != NULL)
 948    {
 949       Fix->Clear(Pkg);
 950       Fix->Protect(Pkg);
 951       Fix->Remove(Pkg);
 952    }
 953
 954    if ((Pkg->CurrentVer == 0 && PurgePkgs == false) ||
 955          (PurgePkgs == true && Pkg->CurrentState == pkgCache::State::NotInstalled))
 956    {
 957       pkgCache::GrpIterator Grp = Pkg.Group();
 958       pkgCache::PkgIterator P = Grp.PackageList();
 959       for (; P.end() != true; P = Grp.NextPkg(P))
 960       {
 961          if (P == Pkg)
 962             continue;
 963          if (P->CurrentVer != 0 || (PurgePkgs == true && P->CurrentState != pkgCache::State::NotInstalled))
 964          {
 965             // TRANSLATORS: Note, this is not an interactive question
 966             ioprintf(c1out,_("Package '%s' is not installed, so not removed. Did you mean '%s'?\n"),
 967                   Pkg.FullName(true).c_str(), P.FullName(true).c_str());
 968             break;
 969          }
 970       }
 971       if (P.end() == true)
 972          ioprintf(c1out,_("Package '%s' is not installed, so not removed\n"),Pkg.FullName(true).c_str());
 973
 974       // MarkInstall refuses to install packages on hold
 975       Pkg->SelectedState = pkgCache::State::Hold;
 976    }
 977    else
 978       Cache->GetDepCache()->MarkDelete(Pkg, PurgePkgs);
 979 }
 980                                                                         /*}}}*/