apt-private/private-install.h

   1 #ifndef APT_PRIVATE_INSTALL_H
   2 #define APT_PRIVATE_INSTALL_H
   3
   4 #include <apt-pkg/cacheset.h>
   5 #include <apt-pkg/cmndline.h>
   6 #include <apt-pkg/strutl.h>
   7
   8 #include "private-cachefile.h"
   9 #include "private-output.h"
  10
  11 #include <apti18n.h>
  12
  13 #define RAMFS_MAGIC     0x858458f6
  14
  15 bool DoInstall(CommandLine &Cmd);
  16
  17 bool DoCacheManipulationFromCommandLine(CommandLine &CmdL, CacheFile &Cache,
  18                                         std::map<unsigned short, APT::VersionSet> &verset);
  19 bool DoCacheManipulationFromCommandLine(CommandLine &CmdL, CacheFile &Cache);
  20
  21 bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,
  22                         bool Safety = true);
  23
  24
  25 // TryToInstall - Mark a package for installation                       /*{{{*/
  26 struct TryToInstall {
  27    pkgCacheFile* Cache;
  28    pkgProblemResolver* Fix;
  29    bool FixBroken;
  30    unsigned long AutoMarkChanged;
  31    APT::PackageSet doAutoInstallLater;
  32
  33    TryToInstall(pkgCacheFile &Cache, pkgProblemResolver *PM, bool const FixBroken) : Cache(&Cache), Fix(PM),
  34                         FixBroken(FixBroken), AutoMarkChanged(0) {};
  35
  36    void operator() (pkgCache::VerIterator const &Ver) {
  37       pkgCache::PkgIterator Pkg = Ver.ParentPkg();
  38
  39       Cache->GetDepCache()->SetCandidateVersion(Ver);
  40       pkgDepCache::StateCache &State = (*Cache)[Pkg];
  41
  42       // Handle the no-upgrade case
  43       if (_config->FindB("APT::Get::upgrade",true) == false && Pkg->CurrentVer != 0)
  44          ioprintf(c1out,_("Skipping %s, it is already installed and upgrade is not set.\n"),
  45                   Pkg.FullName(true).c_str());
  46       // Ignore request for install if package would be new
  47       else if (_config->FindB("APT::Get::Only-Upgrade", false) == true && Pkg->CurrentVer == 0)
  48          ioprintf(c1out,_("Skipping %s, it is not installed and only upgrades are requested.\n"),
  49                   Pkg.FullName(true).c_str());
  50       else {
  51          if (Fix != NULL) {
  52             Fix->Clear(Pkg);
  53             Fix->Protect(Pkg);
  54          }
  55          Cache->GetDepCache()->MarkInstall(Pkg,false);
  56
  57          if (State.Install() == false) {
  58             if (_config->FindB("APT::Get::ReInstall",false) == true) {
  59                if (Pkg->CurrentVer == 0 || Pkg.CurrentVer().Downloadable() == false)
  60                   ioprintf(c1out,_("Reinstallation of %s is not possible, it cannot be downloaded.\n"),
  61                            Pkg.FullName(true).c_str());
  62                else
  63                   Cache->GetDepCache()->SetReInstall(Pkg, true);
  64             } else
  65                ioprintf(c1out,_("%s is already the newest version.\n"),
  66                         Pkg.FullName(true).c_str());
  67          }
  68
  69          // Install it with autoinstalling enabled (if we not respect the minial
  70          // required deps or the policy)
  71          if (FixBroken == false)
  72             doAutoInstallLater.insert(Pkg);
  73       }
  74
  75       // see if we need to fix the auto-mark flag
  76       // e.g. apt-get install foo
  77       // where foo is marked automatic
  78       if (State.Install() == false &&
  79           (State.Flags & pkgCache::Flag::Auto) &&
  80           _config->FindB("APT::Get::ReInstall",false) == false &&
  81           _config->FindB("APT::Get::Only-Upgrade",false) == false &&
  82           _config->FindB("APT::Get::Download-Only",false) == false)
  83       {
  84          ioprintf(c1out,_("%s set to manually installed.\n"),
  85                   Pkg.FullName(true).c_str());
  86          Cache->GetDepCache()->MarkAuto(Pkg,false);
  87          AutoMarkChanged++;
  88       }
  89    }
  90
  91    bool propergateReleaseCandiateSwitching(std::list<std::pair<pkgCache::VerIterator, std::string> > start, std::ostream &out)
  92    {
  93       for (std::list<std::pair<pkgCache::VerIterator, std::string> >::const_iterator s = start.begin();
  94                 s != start.end(); ++s)
  95          Cache->GetDepCache()->SetCandidateVersion(s->first);
  96
  97       bool Success = true;
  98       std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> > Changed;
  99       for (std::list<std::pair<pkgCache::VerIterator, std::string> >::const_iterator s = start.begin();
 100                 s != start.end(); ++s)
 101       {
 102          Changed.push_back(std::make_pair(s->first, pkgCache::VerIterator(*Cache)));
 103          // We continue here even if it failed to enhance the ShowBroken output
 104          Success &= Cache->GetDepCache()->SetCandidateRelease(s->first, s->second, Changed);
 105       }
 106       for (std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> >::const_iterator c = Changed.begin();
 107            c != Changed.end(); ++c)
 108       {
 109          if (c->second.end() == true)
 110             ioprintf(out, _("Selected version '%s' (%s) for '%s'\n"),
 111                      c->first.VerStr(), c->first.RelStr().c_str(), c->first.ParentPkg().FullName(true).c_str());
 112          else if (c->first.ParentPkg()->Group != c->second.ParentPkg()->Group)
 113          {
 114             pkgCache::VerIterator V = (*Cache)[c->first.ParentPkg()].CandidateVerIter(*Cache);
 115             ioprintf(out, _("Selected version '%s' (%s) for '%s' because of '%s'\n"), V.VerStr(),
 116                      V.RelStr().c_str(), V.ParentPkg().FullName(true).c_str(), c->second.ParentPkg().FullName(true).c_str());
 117          }
 118       }
 119       return Success;
 120    }
 121
 122    void doAutoInstall() {
 123       for (APT::PackageSet::const_iterator P = doAutoInstallLater.begin();
 124            P != doAutoInstallLater.end(); ++P) {
 125          pkgDepCache::StateCache &State = (*Cache)[P];
 126          if (State.InstBroken() == false && State.InstPolicyBroken() == false)
 127             continue;
 128          Cache->GetDepCache()->MarkInstall(P, true);
 129       }
 130       doAutoInstallLater.clear();
 131    }
 132 };
 133                                                                         /*}}}*/
 134 // TryToRemove - Mark a package for removal                             /*{{{*/
 135 struct TryToRemove {
 136    pkgCacheFile* Cache;
 137    pkgProblemResolver* Fix;
 138    bool PurgePkgs;
 139
 140    TryToRemove(pkgCacheFile &Cache, pkgProblemResolver *PM) : Cache(&Cache), Fix(PM),
 141                                 PurgePkgs(_config->FindB("APT::Get::Purge", false)) {};
 142
 143    void operator() (pkgCache::VerIterator const &Ver)
 144    {
 145       pkgCache::PkgIterator Pkg = Ver.ParentPkg();
 146
 147       if (Fix != NULL)
 148       {
 149          Fix->Clear(Pkg);
 150          Fix->Protect(Pkg);
 151          Fix->Remove(Pkg);
 152       }
 153
 154       if ((Pkg->CurrentVer == 0 && PurgePkgs == false) ||
 155           (PurgePkgs == true && Pkg->CurrentState == pkgCache::State::NotInstalled))
 156       {
 157          pkgCache::GrpIterator Grp = Pkg.Group();
 158          pkgCache::PkgIterator P = Grp.PackageList();
 159          for (; P.end() != true; P = Grp.NextPkg(P))
 160          {
 161             if (P == Pkg)
 162                continue;
 163             if (P->CurrentVer != 0 || (PurgePkgs == true && P->CurrentState != pkgCache::State::NotInstalled))
 164             {
 165                // TRANSLATORS: Note, this is not an interactive question
 166                ioprintf(c1out,_("Package '%s' is not installed, so not removed. Did you mean '%s'?\n"),
 167                         Pkg.FullName(true).c_str(), P.FullName(true).c_str());
 168                break;
 169             }
 170          }
 171          if (P.end() == true)
 172             ioprintf(c1out,_("Package '%s' is not installed, so not removed\n"),Pkg.FullName(true).c_str());
 173
 174          // MarkInstall refuses to install packages on hold
 175          Pkg->SelectedState = pkgCache::State::Hold;
 176       }
 177       else
 178          Cache->GetDepCache()->MarkDelete(Pkg, PurgePkgs);
 179    }
 180 };
 181                                                                         /*}}}*/
 182
 183
 184 #endif