check in the DepCache::SetCandidateVersion that the package is marked to

[apt.git] / apt-pkg / depcache.cc

diff --git a/apt-pkg/depcache.cc b/apt-pkg/depcache.cc
index 786b20ec0fb8e36796285bdbfc572296c7814f49..594c085a54542a8aaaf89d31b5e94664a573792f 100644 (file)
--- a/apt-pkg/depcache.cc
+++ b/apt-pkg/depcache.cc
@@ -10,6 +10,7 @@
 // Include Files                                                       /*{{{*/
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/version.h>
 // Include Files                                                       /*{{{*/
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/version.h>

+#include <apt-pkg/versionmatch.h>

 #include <apt-pkg/error.h>
 #include <apt-pkg/sptr.h>
 #include <apt-pkg/algorithms.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/sptr.h>
 #include <apt-pkg/algorithms.h>


@@ -165,7 +166,7 @@ bool pkgDepCache::Init(OpProgress *Prog)
 bool pkgDepCache::readStateFile(OpProgress *Prog)                      /*{{{*/
 {
    FileFd state_file;
 bool pkgDepCache::readStateFile(OpProgress *Prog)                      /*{{{*/
 {
    FileFd state_file;

-   string const state = _config->FindDir("Dir::State") + "extended_states";
+   string const state = _config->FindFile("Dir::State::extended_states");

    if(FileExists(state)) {
       state_file.Open(state, FileFd::ReadOnly);
       int const file_size = state_file.Size();
    if(FileExists(state)) {
       state_file.Open(state, FileFd::ReadOnly);
       int const file_size = state_file.Size();


@@ -222,12 +223,12 @@ bool pkgDepCache::writeStateFile(OpProgress *prog, bool InstalledOnly)    /*{{{*/
       std::clog << "pkgDepCache::writeStateFile()" << std::endl;
 
    FileFd StateFile;
       std::clog << "pkgDepCache::writeStateFile()" << std::endl;
 
    FileFd StateFile;

-   string const state = _config->FindDir("Dir::State") + "extended_states";
+   string const state = _config->FindFile("Dir::State::extended_states");

 
    // if it does not exist, create a empty one
    if(!FileExists(state)) 
    {
 
    // if it does not exist, create a empty one
    if(!FileExists(state)) 
    {

-      StateFile.Open(state, FileFd::WriteEmpty);
+      StateFile.Open(state, FileFd::WriteAtomic);

       StateFile.Close();
    }
 
       StateFile.Close();
    }
 


@@ -338,7 +339,7 @@ bool pkgDepCache::CheckDep(DepIterator Dep,int Type,PkgIterator &Res)
    /* Check simple depends. A depends -should- never self match but 
       we allow it anyhow because dpkg does. Technically it is a packaging
       bug. Conflicts may never self match */
    /* Check simple depends. A depends -should- never self match but 
       we allow it anyhow because dpkg does. Technically it is a packaging
       bug. Conflicts may never self match */

-   if (Dep.TargetPkg() != Dep.ParentPkg() || 
+   if (Dep.TargetPkg()->Group != Dep.ParentPkg()->Group ||

        (Dep->Type != Dep::Conflicts && Dep->Type != Dep::DpkgBreaks && Dep->Type != Dep::Obsoletes))
    {
       PkgIterator Pkg = Dep.TargetPkg();
        (Dep->Type != Dep::Conflicts && Dep->Type != Dep::DpkgBreaks && Dep->Type != Dep::Obsoletes))
    {
       PkgIterator Pkg = Dep.TargetPkg();


@@ -367,9 +368,9 @@ bool pkgDepCache::CheckDep(DepIterator Dep,int Type,PkgIterator &Res)
    PkgIterator Pkg = Dep.ParentPkg();
    for (; P.end() != true; P++)
    {
    PkgIterator Pkg = Dep.ParentPkg();
    for (; P.end() != true; P++)
    {

-      /* Provides may never be applied against the same package if it is
-         a conflicts. See the comment above. */
-      if (P.OwnerPkg() == Pkg &&
+      /* Provides may never be applied against the same package (or group)
+         if it is a conflicts. See the comment above. */
+      if (P.OwnerPkg()->Group == Pkg->Group &&

          (Dep->Type == Dep::Conflicts || Dep->Type == Dep::DpkgBreaks))
         continue;
       
          (Dep->Type == Dep::Conflicts || Dep->Type == Dep::DpkgBreaks))
         continue;
       


@@ -875,7 +876,7 @@ void pkgDepCache::Update(OpProgress *Prog)
                a bit we increase with a kill, but we should do something more clever… */
       while(recheck.empty() == false)
         for (std::set<unsigned long>::const_iterator p = recheck.begin();
                a bit we increase with a kill, but we should do something more clever… */
       while(recheck.empty() == false)
         for (std::set<unsigned long>::const_iterator p = recheck.begin();

-            p != recheck.end(); ++p) {
+            p != recheck.end();) {

            if (Prog != 0 && Done%20 == 0)
               Prog->Progress(Done);
            PkgIterator P = PkgIterator(*Cache, Cache->PkgP + *p);
            if (Prog != 0 && Done%20 == 0)
               Prog->Progress(Done);
            PkgIterator P = PkgIterator(*Cache, Cache->PkgP + *p);


@@ -883,7 +884,7 @@ void pkgDepCache::Update(OpProgress *Prog)
               ++killed;
               ++Done;
            }
               ++killed;
               ++Done;
            }

-           recheck.erase(p);
+           recheck.erase(p++);

         }
 
       /* Okay, we have killed a great amount of pseudopackages -
         }
 
       /* Okay, we have killed a great amount of pseudopackages -


@@ -918,7 +919,7 @@ void pkgDepCache::Update(OpProgress *Prog)
         unsigned long const G = *g;
         recheck.erase(g);
         if (unlikely(ReInstallPseudoForGroup(G, recheck) == false))
         unsigned long const G = *g;
         recheck.erase(g);
         if (unlikely(ReInstallPseudoForGroup(G, recheck) == false))

-           _error->Warning(_("Internal error, group '%s' has no installable pseudo package"), GrpIterator(*Cache, Cache->GrpP + *g).Name());
+           _error->Warning(_("Internal error, group '%s' has no installable pseudo package"), GrpIterator(*Cache, Cache->GrpP + G).Name());

       }
    }
 
       }
    }
 


@@ -1149,7 +1150,7 @@ void pkgDepCache::MarkDelete(PkgIterator const &Pkg, bool rPurge,
       return;
 
    if (DebugMarker == true)
       return;
 
    if (DebugMarker == true)

-      std::clog << OutputInDepth(Depth) << "MarkDelete " << Pkg << " FU=" << FromUser << std::endl;
+      std::clog << OutputInDepth(Depth) << (rPurge ? "MarkPurge " : "MarkDelete ") << Pkg << " FU=" << FromUser << std::endl;

 
    RemoveSizes(Pkg);
    RemoveStates(Pkg);
 
    RemoveSizes(Pkg);
    RemoveStates(Pkg);


@@ -1167,6 +1168,15 @@ void pkgDepCache::MarkDelete(PkgIterator const &Pkg, bool rPurge,
    // if we remove the pseudo package, we also need to remove the "real"
    if (Pkg->CurrentVer != 0 && Pkg.CurrentVer().Pseudo() == true)
       MarkDelete(Pkg.Group().FindPkg("all"), rPurge, Depth+1, FromUser);
    // if we remove the pseudo package, we also need to remove the "real"
    if (Pkg->CurrentVer != 0 && Pkg.CurrentVer().Pseudo() == true)
       MarkDelete(Pkg.Group().FindPkg("all"), rPurge, Depth+1, FromUser);

+   else if (rPurge == true && Pkg->CurrentVer == 0 &&
+           Pkg->CurrentState != pkgCache::State::NotInstalled &&
+           strcmp(Pkg.Arch(), "all") != 0)
+   {
+      PkgIterator const allPkg = Pkg.Group().FindPkg("all");
+      if (allPkg.end() == false && allPkg->CurrentVer == 0 &&
+         allPkg->CurrentState != pkgCache::State::NotInstalled)
+        MarkDelete(allPkg, rPurge, Depth+1, FromUser);
+   }

 }
                                                                        /*}}}*/
 // DepCache::IsDeleteOk - check if it is ok to remove this package     /*{{{*/
 }
                                                                        /*}}}*/
 // DepCache::IsDeleteOk - check if it is ok to remove this package     /*{{{*/


@@ -1183,6 +1193,16 @@ bool pkgDepCache::IsDeleteOk(PkgIterator const &Pkg,bool rPurge,
         std::clog << OutputInDepth(Depth) << "Hold prevents MarkDelete of " << Pkg << " FU=" << FromUser << std::endl;
       return false;
    }
         std::clog << OutputInDepth(Depth) << "Hold prevents MarkDelete of " << Pkg << " FU=" << FromUser << std::endl;
       return false;
    }

+   else if (FromUser == false && Pkg->CurrentVer == 0)
+   {
+      StateCache &P = PkgState[Pkg->ID];
+      if (P.InstallVer != 0 && P.Status == 2 && (P.Flags & Flag::Auto) != Flag::Auto)
+      {
+        if (DebugMarker == true)
+           std::clog << OutputInDepth(Depth) << "Manual install request prevents MarkDelete of " << Pkg << std::endl;
+        return false;
+      }
+   }

    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/


@@ -1255,6 +1275,10 @@ void pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst,
    Update(Pkg);
    AddSizes(Pkg);
 
    Update(Pkg);
    AddSizes(Pkg);
 

+   // always trigger the install of the all package for a pseudo package
+   if (P.CandidateVerIter(*Cache).Pseudo() == true)
+      MarkInstall(Pkg.Group().FindPkg("all"), AutoInst, Depth, FromUser, ForceImportantDeps);
+

    if (AutoInst == false)
       return;
 
    if (AutoInst == false)
       return;
 


@@ -1421,10 +1445,16 @@ void pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst,
            VerIterator Ver(*this,*I);
            PkgIterator Pkg = Ver.ParentPkg();
 
            VerIterator Ver(*this,*I);
            PkgIterator Pkg = Ver.ParentPkg();
 

-           if (Start->Type != Dep::DpkgBreaks)
-              MarkDelete(Pkg,false,Depth + 1, false);
-           else if (PkgState[Pkg->ID].CandidateVer != *I)
+           /* The List includes all packages providing this dependency,
+              even providers which are not installed, so skip them. */
+           if (PkgState[Pkg->ID].InstallVer == 0)
+              continue;
+
+           if (PkgState[Pkg->ID].CandidateVer != *I &&
+               Start->Type == Dep::DpkgBreaks)

               MarkInstall(Pkg,true,Depth + 1, false, ForceImportantDeps);
               MarkInstall(Pkg,true,Depth + 1, false, ForceImportantDeps);

+           else
+              MarkDelete(Pkg,false,Depth + 1, false);

         }
         continue;
       }      
         }
         continue;
       }      


@@ -1453,6 +1483,9 @@ bool pkgDepCache::IsInstallOk(PkgIterator const &Pkg,bool AutoInst,
 /* */
 void pkgDepCache::SetReInstall(PkgIterator const &Pkg,bool To)
 {
 /* */
 void pkgDepCache::SetReInstall(PkgIterator const &Pkg,bool To)
 {

+   if (unlikely(Pkg.end() == true))
+      return;
+

    ActionGroup group(*this);
 
    RemoveSizes(Pkg);
    ActionGroup group(*this);
 
    RemoveSizes(Pkg);


@@ -1466,22 +1499,31 @@ void pkgDepCache::SetReInstall(PkgIterator const &Pkg,bool To)
    
    AddStates(Pkg);
    AddSizes(Pkg);
    
    AddStates(Pkg);
    AddSizes(Pkg);

+
+   if (unlikely(Pkg.CurrentVer().end() == true) || Pkg.CurrentVer().Pseudo() == false)
+      return;
+
+   SetReInstall(Pkg.Group().FindPkg("all"), To);

 }
                                                                        /*}}}*/
 // DepCache::SetCandidateVersion - Change the candidate version                /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 }
                                                                        /*}}}*/
 // DepCache::SetCandidateVersion - Change the candidate version                /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-void pkgDepCache::SetCandidateVersion(VerIterator TargetVer)
+void pkgDepCache::SetCandidateVersion(VerIterator TargetVer, bool const &Pseudo)

 {
 {

-   ActionGroup group(*this);

 
    pkgCache::PkgIterator Pkg = TargetVer.ParentPkg();
    StateCache &P = PkgState[Pkg->ID];
 
 
    pkgCache::PkgIterator Pkg = TargetVer.ParentPkg();
    StateCache &P = PkgState[Pkg->ID];
 

+   if (P.CandidateVer == TargetVer)
+      return;
+
+   ActionGroup group(*this);
+

    RemoveSizes(Pkg);
    RemoveStates(Pkg);
 
    RemoveSizes(Pkg);
    RemoveStates(Pkg);
 

-   if (P.CandidateVer == P.InstallVer)
+   if (P.CandidateVer == P.InstallVer && P.Install() == true)

       P.InstallVer = (Version *)TargetVer;
    P.CandidateVer = (Version *)TargetVer;
    P.Update(Pkg,*this);
       P.InstallVer = (Version *)TargetVer;
    P.CandidateVer = (Version *)TargetVer;
    P.Update(Pkg,*this);


@@ -1489,8 +1531,194 @@ void pkgDepCache::SetCandidateVersion(VerIterator TargetVer)
    AddStates(Pkg);
    Update(Pkg);
    AddSizes(Pkg);
    AddStates(Pkg);
    Update(Pkg);
    AddSizes(Pkg);

+
+   if (TargetVer.Pseudo() == false || Pseudo == false)
+      return;
+
+   // the version was pseudo: set all other pseudos also
+   pkgCache::GrpIterator Grp = Pkg.Group();
+   for (Pkg = Grp.FindPkg("any"); Pkg.end() == false; ++Pkg)
+   {
+      StateCache &P = PkgState[Pkg->ID];
+      if (TargetVer.SimilarVer(P.CandidateVerIter(*this)) == true ||
+         (P.CandidateVerIter(*this).Pseudo() == false &&
+          strcmp(Pkg.Arch(), "all") != 0))
+        continue;
+
+      for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
+      {
+        if (TargetVer.SimilarVer(Ver) == false)
+           continue;
+        SetCandidateVersion(Ver, false);
+        break;
+      }
+   }
+}
+                                                                       /*}}}*/
+// DepCache::SetCandidateRelease - Change the candidate version                /*{{{*/
+// ---------------------------------------------------------------------
+/* changes the candidate of a package and walks over all its dependencies
+   to check if it needs to change the candidate of the dependency, too,
+   to reach a installable versionstate */
+bool pkgDepCache::SetCandidateRelease(pkgCache::VerIterator TargetVer,
+                                       std::string const &TargetRel)
+{
+   std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> > Changed;
+   return SetCandidateRelease(TargetVer, TargetRel, Changed);

 }
 }

+bool pkgDepCache::SetCandidateRelease(pkgCache::VerIterator TargetVer,
+                                       std::string const &TargetRel,
+                                       std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> > &Changed)
+{
+   ActionGroup group(*this);
+   SetCandidateVersion(TargetVer);
+
+   if (TargetRel == "installed" || TargetRel == "candidate") // both doesn't make sense in this context
+      return true;
+
+   pkgVersionMatch Match(TargetRel, pkgVersionMatch::Release);
+   // save the position of the last element we will not undo - if we have to
+   std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> >::iterator newChanged = --(Changed.end());
+
+   for (pkgCache::DepIterator D = TargetVer.DependsList(); D.end() == false; ++D)
+   {
+      if (D->Type != pkgCache::Dep::PreDepends && D->Type != pkgCache::Dep::Depends &&
+         ((D->Type != pkgCache::Dep::Recommends && D->Type != pkgCache::Dep::Suggests) ||
+          IsImportantDep(D) == false))
+        continue;
+
+      // walk over an or-group and check if we need to do anything
+      // for simpilicity no or-group is handled as a or-group including one dependency
+      pkgCache::DepIterator Start = D;
+      bool itsFine = false;
+      for (bool stillOr = true; stillOr == true; ++Start)
+      {
+        stillOr = (Start->CompareOp & Dep::Or) == Dep::Or;
+        pkgCache::PkgIterator const P = Start.TargetPkg();
+        // virtual packages can't be a solution
+        if (P.end() == true || (P->ProvidesList == 0 && P->VersionList == 0))
+           continue;
+        pkgCache::VerIterator const Cand = PkgState[P->ID].CandidateVerIter(*this);
+        // no versioned dependency - but is it installable?
+        if (Start.TargetVer() == 0 || Start.TargetVer()[0] == '\0')
+        {
+           // Check if one of the providers is installable
+           if (P->ProvidesList != 0)
+           {
+              pkgCache::PrvIterator Prv = P.ProvidesList();
+              for (; Prv.end() == false; ++Prv)
+              {
+                 pkgCache::VerIterator const C = PkgState[Prv.OwnerPkg()->ID].CandidateVerIter(*this);
+                 if (C.end() == true || C != Prv.OwnerVer() ||
+                     (VersionState(C.DependsList(), DepInstall, DepCandMin, DepCandPolicy) & DepCandMin) != DepCandMin)
+                    continue;
+                 break;
+              }
+              if (Prv.end() == true)
+                 continue;
+           }
+           // no providers, so check if we have an installable candidate version
+           else if (Cand.end() == true ||
+               (VersionState(Cand.DependsList(), DepInstall, DepCandMin, DepCandPolicy) & DepCandMin) != DepCandMin)
+              continue;
+           itsFine = true;
+           break;
+        }
+        if (Cand.end() == true)
+           continue;
+        // check if the current candidate is enough for the versioned dependency - and installable?
+        if (VS().CheckDep(P.CandVersion(), Start->CompareOp, Start.TargetVer()) == true &&
+            (VersionState(Cand.DependsList(), DepInstall, DepCandMin, DepCandPolicy) & DepCandMin) == DepCandMin)
+        {
+           itsFine = true;
+           break;
+        }
+      }
+
+      if (itsFine == true) {
+        // something in the or-group was fine, skip all other members
+        for (; (D->CompareOp & Dep::Or) == Dep::Or; ++D);
+        continue;
+      }

 
 

+      // walk again over the or-group and check each if a candidate switch would help
+      itsFine = false;
+      for (bool stillOr = true; stillOr == true; ++D)
+      {
+        stillOr = (D->CompareOp & Dep::Or) == Dep::Or;
+        // changing candidate will not help if the dependency is not versioned
+        if (D.TargetVer() == 0 || D.TargetVer()[0] == '\0')
+        {
+           if (stillOr == true)
+              continue;
+           break;
+        }
+
+        pkgCache::VerIterator V;
+        if (TargetRel == "newest")
+           V = D.TargetPkg().VersionList();
+        else
+           V = Match.Find(D.TargetPkg());
+
+        // check if the version from this release could satisfy the dependency
+        if (V.end() == true || VS().CheckDep(V.VerStr(), D->CompareOp, D.TargetVer()) == false)
+        {
+           if (stillOr == true)
+              continue;
+           break;
+        }
+
+        pkgCache::VerIterator oldCand = PkgState[D.TargetPkg()->ID].CandidateVerIter(*this);
+        if (V == oldCand)
+        {
+           // Do we already touched this Version? If so, their versioned dependencies are okay, no need to check again
+           for (std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> >::const_iterator c = Changed.begin();
+                c != Changed.end(); ++c)
+           {
+              if (c->first->ParentPkg != V->ParentPkg)
+                 continue;
+              itsFine = true;
+              break;
+           }
+        }
+
+        if (itsFine == false)
+        {
+           // change the candidate
+           Changed.push_back(make_pair(oldCand, TargetVer));
+           if (SetCandidateRelease(V, TargetRel, Changed) == false)
+           {
+              if (stillOr == false)
+                 break;
+              // undo the candidate changing
+              SetCandidateVersion(oldCand);
+              Changed.pop_back();
+              continue;
+           }
+           itsFine = true;
+        }
+
+        // something in the or-group was fine, skip all other members
+        for (; (D->CompareOp & Dep::Or) == Dep::Or; ++D);
+        break;
+      }
+
+      if (itsFine == false && (D->Type == pkgCache::Dep::PreDepends || D->Type == pkgCache::Dep::Depends))
+      {
+        // undo all changes which aren't lead to a solution
+        for (std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> >::const_iterator c = ++newChanged;
+             c != Changed.end(); ++c)
+           SetCandidateVersion(c->first);
+        Changed.erase(newChanged, Changed.end());
+        return false;
+      }
+   }
+   return true;
+}
+                                                                       /*}}}*/
+// DepCache::MarkAuto - set the Auto flag for a package                        /*{{{*/
+// ---------------------------------------------------------------------
+/* */

 void pkgDepCache::MarkAuto(const PkgIterator &Pkg, bool Auto)
 {
   StateCache &state = PkgState[Pkg->ID];
 void pkgDepCache::MarkAuto(const PkgIterator &Pkg, bool Auto)
 {
   StateCache &state = PkgState[Pkg->ID];


@@ -1551,7 +1779,7 @@ const char *pkgDepCache::StateCache::StripEpoch(const char *Ver)
 // ---------------------------------------------------------------------
 /* The default just returns the highest available version that is not
    a source and automatic. */
 // ---------------------------------------------------------------------
 /* The default just returns the highest available version that is not
    a source and automatic. */

-pkgCache::VerIterator pkgDepCache::Policy::GetCandidateVer(PkgIterator Pkg)
+pkgCache::VerIterator pkgDepCache::Policy::GetCandidateVer(PkgIterator const &Pkg)

 {
    /* Not source/not automatic versions cannot be a candidate version 
       unless they are already installed */
 {
    /* Not source/not automatic versions cannot be a candidate version 
       unless they are already installed */


@@ -1569,7 +1797,8 @@ pkgCache::VerIterator pkgDepCache::Policy::GetCandidateVer(PkgIterator Pkg)
 
         /* Stash the highest version of a not-automatic source, we use it
            if there is nothing better */
 
         /* Stash the highest version of a not-automatic source, we use it
            if there is nothing better */

-        if ((J.File()->Flags & Flag::NotAutomatic) != 0)
+        if ((J.File()->Flags & Flag::NotAutomatic) != 0 ||
+            (J.File()->Flags & Flag::ButAutomaticUpgrades) != 0)

         {
            if (Last.end() == true)
               Last = I;
         {
            if (Last.end() == true)
               Last = I;


@@ -1586,7 +1815,7 @@ pkgCache::VerIterator pkgDepCache::Policy::GetCandidateVer(PkgIterator Pkg)
 // Policy::IsImportantDep - True if the dependency is important                /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // Policy::IsImportantDep - True if the dependency is important                /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-bool pkgDepCache::Policy::IsImportantDep(DepIterator Dep)
+bool pkgDepCache::Policy::IsImportantDep(DepIterator const &Dep)

 {
    if(Dep.IsCritical())
       return true;
 {
    if(Dep.IsCritical())
       return true;


@@ -1605,54 +1834,6 @@ bool pkgDepCache::Policy::IsImportantDep(DepIterator Dep)
    else if(Dep->Type == pkgCache::Dep::Suggests)
      return _config->FindB("APT::Install-Suggests", false);
 
    else if(Dep->Type == pkgCache::Dep::Suggests)
      return _config->FindB("APT::Install-Suggests", false);
 

-   return false;
-}
-                                                                       /*}}}*/
-pkgDepCache::DefaultRootSetFunc::DefaultRootSetFunc()                  /*{{{*/
-  : constructedSuccessfully(false)
-{
-  Configuration::Item const *Opts;
-  Opts = _config->Tree("APT::NeverAutoRemove");
-  if (Opts != 0 && Opts->Child != 0)
-    {
-      Opts = Opts->Child;
-      for (; Opts != 0; Opts = Opts->Next)
-       {
-         if (Opts->Value.empty() == true)
-           continue;
-
-         regex_t *p = new regex_t;
-         if(regcomp(p,Opts->Value.c_str(),
-                    REG_EXTENDED | REG_ICASE | REG_NOSUB) != 0)
-           {
-             regfree(p);
-             delete p;
-             _error->Error("Regex compilation error for APT::NeverAutoRemove");
-             return;
-           }
-
-         rootSetRegexp.push_back(p);
-       }
-    }
-
-  constructedSuccessfully = true;
-}
-                                                                       /*}}}*/
-pkgDepCache::DefaultRootSetFunc::~DefaultRootSetFunc()                 /*{{{*/
-{
-  for(unsigned int i = 0; i < rootSetRegexp.size(); i++)
-    {
-      regfree(rootSetRegexp[i]);
-      delete rootSetRegexp[i];
-    }
-}
-                                                                       /*}}}*/
-bool pkgDepCache::DefaultRootSetFunc::InRootSet(const pkgCache::PkgIterator &pkg) /*{{{*/
-{
-   for(unsigned int i = 0; i < rootSetRegexp.size(); i++)
-      if (regexec(rootSetRegexp[i], pkg.Name(), 0, 0, 0) == 0)
-        return true;
-

    return false;
 }
                                                                        /*}}}*/
    return false;
 }
                                                                        /*}}}*/


@@ -1707,8 +1888,11 @@ bool pkgDepCache::MarkRequired(InRootSetFunc &userFunc)
    {
       if(!(PkgState[p->ID].Flags & Flag::Auto) ||
          (p->Flags & Flag::Essential) ||
    {
       if(!(PkgState[p->ID].Flags & Flag::Auto) ||
          (p->Flags & Flag::Essential) ||

-         userFunc.InRootSet(p))
-          
+         userFunc.InRootSet(p) ||
+         // be nice even then a required package violates the policy (#583517)
+         // and do the full mark process also for required packages
+         (p.CurrentVer().end() != true &&
+          p.CurrentVer()->Priority == pkgCache::State::Required))

       {
         // the package is installed (and set to keep)
         if(PkgState[p->ID].Keep() && !p.CurrentVer().end())
       {
         // the package is installed (and set to keep)
         if(PkgState[p->ID].Keep() && !p.CurrentVer().end())


@@ -1785,10 +1969,6 @@ void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &pkg,
 
    // If the version belongs to a Multi-Arch all package
    // we will mark all others in this Group with this version also
 
    // If the version belongs to a Multi-Arch all package
    // we will mark all others in this Group with this version also

-   // Beware: We compare versions here the lazy way: string comparision
-   // this is bad if multiple repositories provide different versions
-   // of the package with an identical version number - but even in this
-   // case the dependencies are likely the same.

    if (ver->MultiArch == pkgCache::Version::All &&
        strcmp(ver.Arch(true), "all") == 0)
    {
    if (ver->MultiArch == pkgCache::Version::All &&
        strcmp(ver.Arch(true), "all") == 0)
    {


@@ -1800,7 +1980,8 @@ void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &pkg,
         for (VerIterator V = P.VersionList();
              V.end() != true; ++V)
         {
         for (VerIterator V = P.VersionList();
              V.end() != true; ++V)
         {

-           if (strcmp(VerStr, V.VerStr()) != 0)
+           if (ver->Hash != V->Hash ||
+               strcmp(VerStr, V.VerStr()) != 0)

               continue;
            MarkPackage(P, V, follow_recommends, follow_suggests);
            break;
               continue;
            MarkPackage(P, V, follow_recommends, follow_suggests);
            break;