don't try to get acquire lock in simulation mode

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

diff --git a/apt-pkg/depcache.cc b/apt-pkg/depcache.cc
index 6271a024a4aa6c340c8bc518e7489537123382d5..f38f956e48c7b110c64ee91f229a7f1e0f021186 100644 (file)
--- a/apt-pkg/depcache.cc
+++ b/apt-pkg/depcache.cc
@@ -13,7 +13,6 @@
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/versionmatch.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/versionmatch.h>
 #include <apt-pkg/error.h>

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

 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/configuration.h>


@@ -23,6 +22,7 @@
 #include <apt-pkg/cacheset.h>
 #include <apt-pkg/pkgcache.h>
 #include <apt-pkg/cacheiterators.h>
 #include <apt-pkg/cacheset.h>
 #include <apt-pkg/pkgcache.h>
 #include <apt-pkg/cacheiterators.h>

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

 #include <apt-pkg/cachefile.h>
 #include <apt-pkg/macros.h>
 
 #include <apt-pkg/cachefile.h>
 #include <apt-pkg/macros.h>
 


@@ -154,7 +154,7 @@ bool pkgDepCache::Init(OpProgress * const Prog)
       State.iFlags = 0;
 
       // Figure out the install version
       State.iFlags = 0;
 
       // Figure out the install version

-      State.CandidateVer = GetCandidateVer(I);
+      State.CandidateVer = LocalPolicy->GetCandidateVer(I);

       State.InstallVer = I.CurrentVer();
       State.Mode = ModeKeep;
 
       State.InstallVer = I.CurrentVer();
       State.Mode = ModeKeep;
 


@@ -348,22 +348,21 @@ bool pkgDepCache::CheckDep(DepIterator const &Dep,int const Type,PkgIterator &Re
       bug. Conflicts may never self match */
    if (Dep.IsIgnorable(Res) == false)
    {
       bug. Conflicts may never self match */
    if (Dep.IsIgnorable(Res) == false)
    {

-      PkgIterator Pkg = Dep.TargetPkg();

       // Check the base package
       if (Type == NowVersion)
       {
       // Check the base package
       if (Type == NowVersion)
       {

-        if (Pkg->CurrentVer != 0 && Dep.IsSatisfied(Pkg.CurrentVer()) == true)
+        if (Res->CurrentVer != 0 && Dep.IsSatisfied(Res.CurrentVer()) == true)

            return true;
       }
       else if (Type == InstallVersion)
       {
            return true;
       }
       else if (Type == InstallVersion)
       {

-        if (PkgState[Pkg->ID].InstallVer != 0 &&
-              Dep.IsSatisfied(PkgState[Pkg->ID].InstVerIter(*this)) == true)
+        if (PkgState[Res->ID].InstallVer != 0 &&
+              Dep.IsSatisfied(PkgState[Res->ID].InstVerIter(*this)) == true)

            return true;
       }
       else if (Type == CandidateVersion)
            return true;
       }
       else if (Type == CandidateVersion)

-        if (PkgState[Pkg->ID].CandidateVer != 0 &&
-              Dep.IsSatisfied(PkgState[Pkg->ID].CandidateVerIter(*this)) == true)
+        if (PkgState[Res->ID].CandidateVer != 0 &&
+              Dep.IsSatisfied(PkgState[Res->ID].CandidateVerIter(*this)) == true)

            return true;
    }
 
            return true;
    }
 


@@ -793,7 +792,7 @@ bool pkgDepCache::MarkKeep(PkgIterator const &Pkg, bool Soft, bool FromUser,
 #endif
 
    if (DebugMarker == true)
 #endif
 
    if (DebugMarker == true)

-      std::clog << OutputInDepth(Depth) << "MarkKeep " << Pkg << " FU=" << FromUser << std::endl;
+      std::clog << OutputInDepth(Depth) << "MarkKeep " << APT::PrettyPkg(this, Pkg) << " FU=" << FromUser << std::endl;

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


@@ -837,8 +836,43 @@ bool pkgDepCache::MarkDelete(PkgIterator const &Pkg, bool rPurge,
 
    ActionGroup group(*this);
 
 
    ActionGroup group(*this);
 

+   if (FromUser == false)
+   {
+      VerIterator const PV = P.InstVerIter(*this);
+      if (PV.end() == false)
+      {
+        // removed metapackages mark their dependencies as manual to prevent in "desktop depends browser, texteditor"
+        // the removal of browser to suggest the removal of desktop and texteditor.
+        // We ignore the auto-bit here as we can't deal with metapackage cascardes otherwise.
+        // We do not check for or-groups here as we don't know which package takes care of
+        // providing the feature the user likes e.g.:  browser1 | browser2 | browser3
+        // Temporary removals are effected by this as well, which is bad, but unlikely in practice
+        bool const PinNeverMarkAutoSection = (PV->Section != 0 && ConfigValueInSubTree("APT::Never-MarkAuto-Sections", PV.Section()));
+        if (PinNeverMarkAutoSection)
+        {
+           for (DepIterator D = PV.DependsList(); D.end() != true; ++D)
+           {
+              if (D.IsMultiArchImplicit() == true || D.IsNegative() == true || IsImportantDep(D) == false)
+                 continue;
+
+              pkgCacheFile CacheFile(this);
+              APT::VersionList verlist = APT::VersionList::FromDependency(CacheFile, D, APT::CacheSetHelper::INSTALLED);
+              for (auto const &V : verlist)
+              {
+                 PkgIterator const DP = V.ParentPkg();
+                 if(DebugAutoInstall == true)
+                    std::clog << OutputInDepth(Depth) << "Setting " << DP.FullName(false) << " NOT as auto-installed (direct "
+                       << D.DepType() << " of " << Pkg.FullName(false) << " which is in APT::Never-MarkAuto-Sections)" << std::endl;
+
+                 MarkAuto(DP, false);
+              }
+           }
+        }
+      }
+   }
+

    if (DebugMarker == true)
    if (DebugMarker == true)

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

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


@@ -874,7 +908,7 @@ bool pkgDepCache::IsDeleteOkProtectInstallRequests(PkgIterator const &Pkg,
       if (P.InstallVer != 0 && P.Status == 2 && (P.Flags & Flag::Auto) != Flag::Auto)
       {
         if (DebugMarker == true)
       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;
+           std::clog << OutputInDepth(Depth) << "Manual install request prevents MarkDelete of " << APT::PrettyPkg(this, Pkg) << std::endl;

         return false;
       }
    }
         return false;
       }
    }


@@ -924,7 +958,7 @@ bool pkgDepCache::IsModeChangeOk(ModeList const mode, PkgIterator const &Pkg,
    {
       if (unlikely(DebugMarker == true))
         std::clog << OutputInDepth(Depth) << "Ignore Mark" << PrintMode(mode)
    {
       if (unlikely(DebugMarker == true))
         std::clog << OutputInDepth(Depth) << "Ignore Mark" << PrintMode(mode)

-                  << " of " << Pkg << " as its mode (" << PrintMode(P.Mode)
+                  << " of " << APT::PrettyPkg(this, Pkg) << " as its mode (" << PrintMode(P.Mode)

                   << ") is protected" << std::endl;
       return false;
    }
                   << ") is protected" << std::endl;
       return false;
    }


@@ -934,7 +968,7 @@ bool pkgDepCache::IsModeChangeOk(ModeList const mode, PkgIterator const &Pkg,
    {
       if (unlikely(DebugMarker == true))
         std::clog << OutputInDepth(Depth) << "Hold prevents Mark" << PrintMode(mode)
    {
       if (unlikely(DebugMarker == true))
         std::clog << OutputInDepth(Depth) << "Hold prevents Mark" << PrintMode(mode)

-                  << " of " << Pkg << std::endl;
+                  << " of " << APT::PrettyPkg(this, Pkg) << std::endl;

       return false;
    }
 
       return false;
    }
 


@@ -983,6 +1017,8 @@ struct CompareProviders {
         if (instA != instB)
            return instA == false;
       }
         if (instA != instB)
            return instA == false;
       }

+      if ((A->CurrentVer == 0 || B->CurrentVer == 0) && A->CurrentVer != B->CurrentVer)
+        return A->CurrentVer == 0;

       // Prefer packages in the same group as the target; e.g. foo:i386, foo:amd64
       if (A->Group != B->Group)
       {
       // Prefer packages in the same group as the target; e.g. foo:i386, foo:amd64
       if (A->Group != B->Group)
       {


@@ -1092,9 +1128,30 @@ bool pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst,
       return true;
 
    if (DebugMarker == true)
       return true;
 
    if (DebugMarker == true)

-      std::clog << OutputInDepth(Depth) << "MarkInstall " << Pkg << " FU=" << FromUser << std::endl;
+      std::clog << OutputInDepth(Depth) << "MarkInstall " << APT::PrettyPkg(this, Pkg) << " FU=" << FromUser << std::endl;

 
 

-   DepIterator Dep = P.InstVerIter(*this).DependsList();
+   bool MoveAutoBitToDependencies = false;
+   VerIterator const PV = P.InstVerIter(*this);
+   if (unlikely(PV.end() == true))
+      return false;
+   else if (PV->Section != 0 && (P.Flags & Flag::Auto) != Flag::Auto)
+   {
+      VerIterator const CurVer = Pkg.CurrentVer();
+      if (CurVer.end() == false && CurVer->Section != 0 && strcmp(CurVer.Section(), PV.Section()) != 0)
+      {
+        bool const CurVerInMoveSection = ConfigValueInSubTree("APT::Move-Autobit-Sections", CurVer.Section());
+        bool const InstVerInMoveSection = ConfigValueInSubTree("APT::Move-Autobit-Sections", PV.Section());
+        MoveAutoBitToDependencies = (CurVerInMoveSection == false && InstVerInMoveSection == true);
+        if (MoveAutoBitToDependencies == true)
+        {
+           if(DebugAutoInstall == true)
+              std::clog << OutputInDepth(Depth) << "Setting " << Pkg.FullName(false) << " as auto-installed, moving manual to its dependencies" << std::endl;
+           MarkAuto(Pkg, true);
+        }
+      }
+   }
+
+   DepIterator Dep = PV.DependsList();

    for (; Dep.end() != true;)
    {
       // Grok or groups
    for (; Dep.end() != true;)
    {
       // Grok or groups


@@ -1127,7 +1184,7 @@ bool pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst,
 
       /* unsatisfiable dependency: IsInstallOkDependenciesSatisfiableByCandidates
          would have prevented us to get here if not overridden, so just skip
 
       /* unsatisfiable dependency: IsInstallOkDependenciesSatisfiableByCandidates
          would have prevented us to get here if not overridden, so just skip

-        over the problem here as the frontend will know what it is doing */
+        over the problem here as the front-end will know what it is doing */

       if (Ors == 1 && (DepState[Start->ID] &DepCVer) != DepCVer && Start.IsNegative() == false)
         continue;
 
       if (Ors == 1 && (DepState[Start->ID] &DepCVer) != DepCVer && Start.IsNegative() == false)
         continue;
 


@@ -1206,14 +1263,17 @@ bool pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst,
               verlist.erase(InstVer);
               continue;
            }
               verlist.erase(InstVer);
               continue;
            }

+

            // now check if we should consider it a automatic dependency or not
            // now check if we should consider it a automatic dependency or not

-           if(InstPkg->CurrentVer == 0 && InstVer->Section != 0 && ConfigValueInSubTree("APT::Never-MarkAuto-Sections", InstVer.Section()))
+           if(InstPkg->CurrentVer == 0 && MoveAutoBitToDependencies)

            {
               if(DebugAutoInstall == true)
            {
               if(DebugAutoInstall == true)

-                 std::clog << OutputInDepth(Depth) << "Setting NOT as auto-installed (direct "
-                            << Start.DepType() << " of pkg in APT::Never-MarkAuto-Sections)" << std::endl;
+                 std::clog << OutputInDepth(Depth) << "Setting " << InstPkg.FullName(false) << " NOT as auto-installed (direct "
+                    << Start.DepType() << " of " << Pkg.FullName(false) << " which is manual and in APT::Move-Autobit-Sections)" << std::endl;

               MarkAuto(InstPkg, false);
            }
               MarkAuto(InstPkg, false);
            }

+
+

            break;
         } while(true);
         continue;
            break;
         } while(true);
         continue;


@@ -1223,9 +1283,9 @@ bool pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst,
         Otherwise we remove the offender if needed */
       else if (Start.IsNegative() == true && Start->Type != pkgCache::Dep::Obsoletes)
       {
         Otherwise we remove the offender if needed */
       else if (Start.IsNegative() == true && Start->Type != pkgCache::Dep::Obsoletes)
       {

-        SPtrArray<Version *> List = Start.AllTargets();
+        std::unique_ptr<Version *[]> List(Start.AllTargets());

         pkgCache::PkgIterator TrgPkg = Start.TargetPkg();
         pkgCache::PkgIterator TrgPkg = Start.TargetPkg();

-        for (Version **I = List; *I != 0; I++)
+        for (Version **I = List.get(); *I != 0; I++)

         {
            VerIterator Ver(*this,*I);
            PkgIterator Pkg = Ver.ParentPkg();
         {
            VerIterator Ver(*this,*I);
            PkgIterator Pkg = Ver.ParentPkg();


@@ -1301,7 +1361,7 @@ bool pkgDepCache::IsInstallOkMultiArchSameVersionSynced(PkgIterator const &Pkg,
       // not having a candidate or being in sync
       // (simple string-compare as stuff like '1' == '0:1-0' can't happen here)
       VerIterator CV = PkgState[P->ID].CandidateVerIter(*this);
       // not having a candidate or being in sync
       // (simple string-compare as stuff like '1' == '0:1-0' can't happen here)
       VerIterator CV = PkgState[P->ID].CandidateVerIter(*this);

-      if (CV.end() == true || strcmp(Pkg.CandVersion(), CV.VerStr()) == 0)
+      if (CV.end() == true || strcmp(CandVer.VerStr(), CV.VerStr()) == 0)

         continue;
 
       // packages losing M-A:same can be out-of-sync
         continue;
 
       // packages losing M-A:same can be out-of-sync


@@ -1314,9 +1374,9 @@ bool pkgDepCache::IsInstallOkMultiArchSameVersionSynced(PkgIterator const &Pkg,
 
       PkgState[Pkg->ID].iFlags |= AutoKept;
       if (unlikely(DebugMarker == true))
 
       PkgState[Pkg->ID].iFlags |= AutoKept;
       if (unlikely(DebugMarker == true))

-        std::clog << OutputInDepth(Depth) << "Ignore MarkInstall of " << Pkg
-           << " as it is not in sync with its M-A:same sibling " << P
-           << " (" << Pkg.CandVersion() << " != " << CV.VerStr() << ")" << std::endl;
+        std::clog << OutputInDepth(Depth) << "Ignore MarkInstall of " << APT::PrettyPkg(this, Pkg)
+           << " as it is not in sync with its M-A:same sibling " << APT::PrettyPkg(this, P)
+           << " (" << CandVer.VerStr() << " != " << CV.VerStr() << ")" << std::endl;

       return false;
    }
 
       return false;
    }
 


@@ -1357,12 +1417,20 @@ bool pkgDepCache::IsInstallOkDependenciesSatisfiableByCandidates(PkgIterator con
       if (Ors == 1 && (DepState[Start->ID] &DepCVer) != DepCVer)
       {
         if (DebugAutoInstall == true)
       if (Ors == 1 && (DepState[Start->ID] &DepCVer) != DepCVer)
       {
         if (DebugAutoInstall == true)

-           std::clog << OutputInDepth(Depth) << Start << " can't be satisfied!" << std::endl;
+           std::clog << OutputInDepth(Depth) << APT::PrettyDep(this, Start) << " can't be satisfied!" << std::endl;

 
         // the dependency is critical, but can't be installed, so discard the candidate
         // as the problemresolver will trip over it otherwise trying to install it (#735967)
         if (Pkg->CurrentVer != 0 && (PkgState[Pkg->ID].iFlags & Protected) != Protected)
 
         // the dependency is critical, but can't be installed, so discard the candidate
         // as the problemresolver will trip over it otherwise trying to install it (#735967)
         if (Pkg->CurrentVer != 0 && (PkgState[Pkg->ID].iFlags & Protected) != Protected)

+         {

            SetCandidateVersion(Pkg.CurrentVer());
            SetCandidateVersion(Pkg.CurrentVer());

+            StateCache &State = PkgState[Pkg->ID];
+           if (State.Mode != ModeDelete)
+           {
+              State.Mode = ModeKeep;
+              State.Update(Pkg, *this);
+           }
+         }

         return false;
       }
    }
         return false;
       }
    }


@@ -1410,6 +1478,11 @@ void pkgDepCache::SetReInstall(PkgIterator const &Pkg,bool To)
    }
 }
                                                                        /*}}}*/
    }
 }
                                                                        /*}}}*/

+pkgCache::VerIterator pkgDepCache::GetCandidateVersion(PkgIterator const &Pkg)/*{{{*/
+{
+   return PkgState[Pkg->ID].CandidateVerIter(*this);
+}
+                                                                       /*}}}*/

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


@@ -1631,11 +1704,7 @@ void pkgDepCache::StateCache::Update(PkgIterator Pkg,pkgCache &Cache)
    CurVersion = "";
    if (Pkg->CurrentVer != 0)
       CurVersion = Pkg.CurrentVer().VerStr();
    CurVersion = "";
    if (Pkg->CurrentVer != 0)
       CurVersion = Pkg.CurrentVer().VerStr();

-   
-   // Strip off the epochs for display
-   CurVersion = StripEpoch(CurVersion);
-   CandVersion = StripEpoch(CandVersion);
-   
+

    // Figure out if its up or down or equal
    Status = Ver.CompareVer(Pkg.CurrentVer());
    if (Pkg->CurrentVer == 0 || Pkg->VersionList == 0 || CandidateVer == 0)
    // Figure out if its up or down or equal
    Status = Ver.CompareVer(Pkg.CurrentVer());
    if (Pkg->CurrentVer == 0 || Pkg->VersionList == 0 || CandidateVer == 0)


@@ -1722,6 +1791,8 @@ bool pkgDepCache::Policy::IsImportantDep(DepIterator const &Dep) const
 // Policy::GetPriority - Get the priority of the package pin           /*{{{*/
 APT_CONST signed short pkgDepCache::Policy::GetPriority(pkgCache::PkgIterator const &/*Pkg*/)
 { return 0; }
 // Policy::GetPriority - Get the priority of the package pin           /*{{{*/
 APT_CONST signed short pkgDepCache::Policy::GetPriority(pkgCache::PkgIterator const &/*Pkg*/)
 { return 0; }

+APT_CONST signed short pkgDepCache::Policy::GetPriority(pkgCache::VerIterator const &/*Ver*/, bool /*ConsiderFiles*/)
+{ return 0; }

 APT_CONST signed short pkgDepCache::Policy::GetPriority(pkgCache::PkgFileIterator const &/*File*/)
 { return 0; }
                                                                        /*}}}*/
 APT_CONST signed short pkgDepCache::Policy::GetPriority(pkgCache::PkgFileIterator const &/*File*/)
 { return 0; }
                                                                        /*}}}*/


@@ -1952,7 +2023,7 @@ bool pkgDepCache::MarkAndSweep(InRootSetFunc &rootFunc)
 }
 bool pkgDepCache::MarkAndSweep()
 {
 }
 bool pkgDepCache::MarkAndSweep()
 {

-   std::auto_ptr<InRootSetFunc> f(GetRootSetFunc());
+   std::unique_ptr<InRootSetFunc> f(GetRootSetFunc());

    if(f.get() != NULL)
       return MarkAndSweep(*f.get());
    else
    if(f.get() != NULL)
       return MarkAndSweep(*f.get());
    else