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/sourcelist.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)
 531 {
 532    std::map<unsigned short, APT::VersionSet> verset;
 533    return DoCacheManipulationFromCommandLine(CmdL, Cache, verset);
 534 }
 535 bool DoCacheManipulationFromCommandLine(CommandLine &CmdL, CacheFile &Cache,
 536                                         std::map<unsigned short, APT::VersionSet> &verset)
 537 {
 538
 539    // Enter the special broken fixing mode if the user specified arguments
 540    bool BrokenFix = false;
 541    if (Cache->BrokenCount() != 0)
 542       BrokenFix = true;
 543
 544    SPtr<pkgProblemResolver> Fix;
 545    if (_config->FindB("APT::Get::CallResolver", true) == true)
 546       Fix = new pkgProblemResolver(Cache);
 547
 548    unsigned short fallback = MOD_INSTALL;
 549    if (strcasecmp(CmdL.FileList[0],"remove") == 0)
 550       fallback = MOD_REMOVE;
 551    else if (strcasecmp(CmdL.FileList[0], "purge") == 0)
 552    {
 553       _config->Set("APT::Get::Purge", true);
 554       fallback = MOD_REMOVE;
 555    }
 556    else if (strcasecmp(CmdL.FileList[0], "autoremove") == 0)
 557    {
 558       _config->Set("APT::Get::AutomaticRemove", "true");
 559       fallback = MOD_REMOVE;
 560    }
 561
 562    std::list<APT::VersionSet::Modifier> mods;
 563    mods.push_back(APT::VersionSet::Modifier(MOD_INSTALL, "+",
 564                 APT::VersionSet::Modifier::POSTFIX, APT::VersionSet::CANDIDATE));
 565    mods.push_back(APT::VersionSet::Modifier(MOD_REMOVE, "-",
 566                 APT::VersionSet::Modifier::POSTFIX, APT::VersionSet::NEWEST));
 567    CacheSetHelperAPTGet helper(c0out);
 568    verset = APT::VersionSet::GroupedFromCommandLine(Cache,
 569                 CmdL.FileList + 1, mods, fallback, helper);
 570
 571    if (_error->PendingError() == true)
 572    {
 573       helper.showVirtualPackageErrors(Cache);
 574       return false;
 575    }
 576
 577
 578   TryToInstall InstallAction(Cache, Fix, BrokenFix);
 579   TryToRemove RemoveAction(Cache, Fix);
 580
 581    // new scope for the ActionGroup
 582    {
 583       pkgDepCache::ActionGroup group(Cache);
 584       unsigned short const order[] = { MOD_REMOVE, MOD_INSTALL, 0 };
 585
 586       for (unsigned short i = 0; order[i] != 0; ++i)
 587       {
 588          if (order[i] == MOD_INSTALL)
 589             InstallAction = std::for_each(verset[MOD_INSTALL].begin(), verset[MOD_INSTALL].end(), InstallAction);
 590          else if (order[i] == MOD_REMOVE)
 591             RemoveAction = std::for_each(verset[MOD_REMOVE].begin(), verset[MOD_REMOVE].end(), RemoveAction);
 592       }
 593
 594       if (Fix != NULL && _config->FindB("APT::Get::AutoSolving", true) == true)
 595       {
 596          for (unsigned short i = 0; order[i] != 0; ++i)
 597          {
 598             if (order[i] != MOD_INSTALL)
 599                continue;
 600             InstallAction.propergateReleaseCandiateSwitching(helper.selectedByRelease, c0out);
 601             InstallAction.doAutoInstall();
 602          }
 603       }
 604
 605       if (_error->PendingError() == true)
 606       {
 607          return false;
 608       }
 609
 610       /* If we are in the Broken fixing mode we do not attempt to fix the
 611          problems. This is if the user invoked install without -f and gave
 612          packages */
 613       if (BrokenFix == true && Cache->BrokenCount() != 0)
 614       {
 615          c1out << _("You might want to run 'apt-get -f install' to correct these:") << std::endl;
 616          ShowBroken(c1out,Cache,false);
 617          return _error->Error(_("Unmet dependencies. Try 'apt-get -f install' with no packages (or specify a solution)."));
 618       }
 619
 620       if (Fix != NULL)
 621       {
 622          // Call the scored problem resolver
 623          Fix->Resolve(true);
 624       }
 625
 626       // Now we check the state of the packages,
 627       if (Cache->BrokenCount() != 0)
 628       {
 629          c1out <<
 630             _("Some packages could not be installed. This may mean that you have\n"
 631               "requested an impossible situation or if you are using the unstable\n"
 632               "distribution that some required packages have not yet been created\n"
 633               "or been moved out of Incoming.") << std::endl;
 634          /*
 635          if (Packages == 1)
 636          {
 637             c1out << std::endl;
 638             c1out <<
 639                _("Since you only requested a single operation it is extremely likely that\n"
 640                  "the package is simply not installable and a bug report against\n"
 641                  "that package should be filed.") << std::endl;
 642          }
 643          */
 644
 645          c1out << _("The following information may help to resolve the situation:") << std::endl;
 646          c1out << std::endl;
 647          ShowBroken(c1out,Cache,false);
 648          if (_error->PendingError() == true)
 649             return false;
 650          else
 651             return _error->Error(_("Broken packages"));
 652       }
 653    }
 654    if (!DoAutomaticRemove(Cache))
 655       return false;
 656
 657    // if nothing changed in the cache, but only the automark information
 658    // we write the StateFile here, otherwise it will be written in
 659    // cache.commit()
 660    if (InstallAction.AutoMarkChanged > 0 &&
 661        Cache->DelCount() == 0 && Cache->InstCount() == 0 &&
 662        Cache->BadCount() == 0 &&
 663        _config->FindB("APT::Get::Simulate",false) == false)
 664       Cache->writeStateFile(NULL);
 665
 666    return true;
 667 }
 668                                                                         /*}}}*/
 669 // DoInstall - Install packages from the command line                   /*{{{*/
 670 // ---------------------------------------------------------------------
 671 /* Install named packages */
 672 bool DoInstall(CommandLine &CmdL)
 673 {
 674    CacheFile Cache;
 675    // first check for local pkgs and add them to the cache
 676    for (const char **I = CmdL.FileList; *I != 0; I++)
 677    {
 678       if(FileExists(*I))
 679       {
 680          // FIXME: make this more elegant
 681          std::string TypeStr = flExtension(*I) + "-file";
 682          pkgSourceList::Type *Type = pkgSourceList::Type::GetType(TypeStr.c_str());
 683          if(Type != 0)
 684          {
 685             std::vector<metaIndex *> List;
 686             std::map<std::string, std::string> Options;
 687             if(Type->CreateItem(List, *I, "", "", Options))
 688             {
 689                // we have our own CacheFile that gives us a SourceList
 690                // with superpowerz
 691                SourceList *sources = (SourceList*)Cache.GetSourceList();
 692                sources->AddMetaIndex(List[0]);
 693             }
 694          }
 695       }
 696    }
 697
 698    // then open the cache
 699    if (Cache.OpenForInstall() == false ||
 700        Cache.CheckDeps(CmdL.FileSize() != 1) == false)
 701       return false;
 702
 703    std::map<unsigned short, APT::VersionSet> verset;
 704
 705    if(!DoCacheManipulationFromCommandLine(CmdL, Cache, verset))
 706       return false;
 707
 708    /* Print out a list of packages that are going to be installed extra
 709       to what the user asked */
 710    if (Cache->InstCount() != verset[MOD_INSTALL].size())
 711    {
 712       std::string List;
 713       std::string VersionsList;
 714       for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 715       {
 716          pkgCache::PkgIterator I(Cache,Cache.List[J]);
 717          if ((*Cache)[I].Install() == false)
 718             continue;
 719          pkgCache::VerIterator Cand = Cache[I].CandidateVerIter(Cache);
 720
 721          if (verset[MOD_INSTALL].find(Cand) != verset[MOD_INSTALL].end())
 722             continue;
 723
 724          List += I.FullName(true) + " ";
 725          VersionsList += std::string(Cache[I].CandVersion) + "\n";
 726       }
 727
 728       ShowList(c1out,_("The following extra packages will be installed:"),List,VersionsList);
 729    }
 730
 731    /* Print out a list of suggested and recommended packages */
 732    {
 733       std::string SuggestsList, RecommendsList;
 734       std::string SuggestsVersions, RecommendsVersions;
 735       for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 736       {
 737          pkgCache::PkgIterator Pkg(Cache,Cache.List[J]);
 738
 739          /* Just look at the ones we want to install */
 740          if ((*Cache)[Pkg].Install() == false)
 741            continue;
 742
 743          // get the recommends/suggests for the candidate ver
 744          pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
 745          for (pkgCache::DepIterator D = CV.DependsList(); D.end() == false; )
 746          {
 747             pkgCache::DepIterator Start;
 748             pkgCache::DepIterator End;
 749             D.GlobOr(Start,End); // advances D
 750
 751             // FIXME: we really should display a or-group as a or-group to the user
 752             //        the problem is that ShowList is incapable of doing this
 753             std::string RecommendsOrList,RecommendsOrVersions;
 754             std::string SuggestsOrList,SuggestsOrVersions;
 755             bool foundInstalledInOrGroup = false;
 756             for(;;)
 757             {
 758                /* Skip if package is  installed already, or is about to be */
 759                std::string target = Start.TargetPkg().FullName(true) + " ";
 760                pkgCache::PkgIterator const TarPkg = Start.TargetPkg();
 761                if (TarPkg->SelectedState == pkgCache::State::Install ||
 762                    TarPkg->SelectedState == pkgCache::State::Hold ||
 763                    Cache[Start.TargetPkg()].Install())
 764                {
 765                   foundInstalledInOrGroup=true;
 766                   break;
 767                }
 768
 769                /* Skip if we already saw it */
 770                if (int(SuggestsList.find(target)) != -1 || int(RecommendsList.find(target)) != -1)
 771                {
 772                   foundInstalledInOrGroup=true;
 773                   break;
 774                }
 775
 776                // this is a dep on a virtual pkg, check if any package that provides it
 777                // should be installed
 778                if(Start.TargetPkg().ProvidesList() != 0)
 779                {
 780                   pkgCache::PrvIterator I = Start.TargetPkg().ProvidesList();
 781                   for (; I.end() == false; ++I)
 782                   {
 783                      pkgCache::PkgIterator Pkg = I.OwnerPkg();
 784                      if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer() &&
 785                          Pkg.CurrentVer() != 0)
 786                         foundInstalledInOrGroup=true;
 787                   }
 788                }
 789
 790                if (Start->Type == pkgCache::Dep::Suggests)
 791                {
 792                   SuggestsOrList += target;
 793                   SuggestsOrVersions += std::string(Cache[Start.TargetPkg()].CandVersion) + "\n";
 794                }
 795
 796                if (Start->Type == pkgCache::Dep::Recommends)
 797                {
 798                   RecommendsOrList += target;
 799                   RecommendsOrVersions += std::string(Cache[Start.TargetPkg()].CandVersion) + "\n";
 800                }
 801
 802                if (Start >= End)
 803                   break;
 804                ++Start;
 805             }
 806
 807             if(foundInstalledInOrGroup == false)
 808             {
 809                RecommendsList += RecommendsOrList;
 810                RecommendsVersions += RecommendsOrVersions;
 811                SuggestsList += SuggestsOrList;
 812                SuggestsVersions += SuggestsOrVersions;
 813             }
 814
 815          }
 816       }
 817
 818       ShowList(c1out,_("Suggested packages:"),SuggestsList,SuggestsVersions);
 819       ShowList(c1out,_("Recommended packages:"),RecommendsList,RecommendsVersions);
 820
 821    }
 822
 823    // See if we need to prompt
 824    // FIXME: check if really the packages in the set are going to be installed
 825    if (Cache->InstCount() == verset[MOD_INSTALL].size() && Cache->DelCount() == 0)
 826       return InstallPackages(Cache,false,false);
 827
 828    return InstallPackages(Cache,false);
 829 }
 830                                                                         /*}}}*/