rework hashsum verification in the acquire system

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

diff --git a/apt-pkg/depcache.h b/apt-pkg/depcache.h
index dba3e22dcb467ac03c4f6c61294faea5a6eb49c4..20d263c67e11179492f211dcbf3f5135a137f5ca 100644 (file)
--- a/apt-pkg/depcache.h
+++ b/apt-pkg/depcache.h
@@ -15,7 +15,7 @@
    
    This structure is important to support the readonly status of the cache 
    file. When the data is saved the cache will be refereshed from our 
    
    This structure is important to support the readonly status of the cache 
    file. When the data is saved the cache will be refereshed from our 

-   internal rep and written to disk. Then the actual persistant data 
+   internal rep and written to disk. Then the actual persistent data

    files will be put on the disk.
 
    Each dependency is compared against 3 target versions to produce to
    files will be put on the disk.
 
    Each dependency is compared against 3 target versions to produce to


@@ -40,12 +40,27 @@
 
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/pkgcache.h>
 
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/pkgcache.h>

-#include <apt-pkg/progress.h>
-#include <apt-pkg/error.h>
+#include <apt-pkg/cacheiterators.h>
+#include <apt-pkg/macros.h>
+
+#include <stddef.h>

 
 

-#include <vector>

 #include <memory>
 #include <memory>

+#include <list>
+#include <string>
+#include <utility>
+
+#ifndef APT_8_CLEANER_HEADERS
+#include <apt-pkg/progress.h>
+#include <apt-pkg/error.h>
+#endif
+#ifndef APT_10_CLEANER_HEADERS

 #include <set>
 #include <set>

+#include <vector>
+#endif
+
+class OpProgress;
+class pkgVersioningSystem;

 
 class pkgDepCache : protected pkgCache::Namespace
 {
 
 class pkgDepCache : protected pkgCache::Namespace
 {


@@ -55,7 +70,7 @@ class pkgDepCache : protected pkgCache::Namespace
    class InRootSetFunc
    {
    public:
    class InRootSetFunc
    {
    public:

-     virtual bool InRootSet(const pkgCache::PkgIterator &pkg) {return false;};
+     virtual bool InRootSet(const pkgCache::PkgIterator &/*pkg*/) {return false;};

      virtual ~InRootSetFunc() {};
    };
 
      virtual ~InRootSetFunc() {};
    };
 


@@ -76,7 +91,7 @@ class pkgDepCache : protected pkgCache::Namespace
     *  \param follow_suggests If \b true, suggestions of the package
     *  will be recursively marked.
     */
     *  \param follow_suggests If \b true, suggestions of the package
     *  will be recursively marked.
     */

-   void MarkPackage(const pkgCache::PkgIterator &pkg,
+   APT_HIDDEN void MarkPackage(const pkgCache::PkgIterator &pkg,

                    const pkgCache::VerIterator &ver,
                    bool const &follow_recommends,
                    bool const &follow_suggests);
                    const pkgCache::VerIterator &ver,
                    bool const &follow_recommends,
                    bool const &follow_suggests);


@@ -119,10 +134,10 @@ class pkgDepCache : protected pkgCache::Namespace
                        DepCandPolicy = (1 << 4), DepCandMin = (1 << 5)};
    
    // These flags are used in StateCache::iFlags
                        DepCandPolicy = (1 << 4), DepCandMin = (1 << 5)};
    
    // These flags are used in StateCache::iFlags

-   enum InternalFlags {AutoKept = (1 << 0), Purge = (1 << 1), ReInstall = (1 << 2)};
+   enum InternalFlags {AutoKept = (1 << 0), Purge = (1 << 1), ReInstall = (1 << 2), Protected = (1 << 3)};

       
    enum VersionTypes {NowVersion, InstallVersion, CandidateVersion};
       
    enum VersionTypes {NowVersion, InstallVersion, CandidateVersion};

-   enum ModeList {ModeDelete = 0, ModeKeep = 1, ModeInstall = 2};
+   enum ModeList {ModeDelete = 0, ModeKeep = 1, ModeInstall = 2, ModeGarbage = 3};

 
    /** \brief Represents an active action group.
     *
 
    /** \brief Represents an active action group.
     *


@@ -154,7 +169,7 @@ class pkgDepCache : protected pkgCache::Namespace
        bool released;
 
        /** Action groups are noncopyable. */
        bool released;
 
        /** Action groups are noncopyable. */

-       ActionGroup(const ActionGroup &other);
+       APT_HIDDEN ActionGroup(const ActionGroup &other);

    public:
        /** \brief Create a new ActionGroup.
        *
    public:
        /** \brief Create a new ActionGroup.
        *


@@ -225,13 +240,15 @@ class pkgDepCache : protected pkgCache::Namespace
       unsigned char DepState;          // DepState Flags
 
       // Update of candidate version
       unsigned char DepState;          // DepState Flags
 
       // Update of candidate version

-      const char *StripEpoch(const char *Ver);
+      const char *StripEpoch(const char *Ver) APT_PURE;

       void Update(PkgIterator Pkg,pkgCache &Cache);
       
       // Various test members for the current status of the package
       inline bool NewInstall() const {return Status == 2 && Mode == ModeInstall;};
       inline bool Delete() const {return Mode == ModeDelete;};
       void Update(PkgIterator Pkg,pkgCache &Cache);
       
       // Various test members for the current status of the package
       inline bool NewInstall() const {return Status == 2 && Mode == ModeInstall;};
       inline bool Delete() const {return Mode == ModeDelete;};

+      inline bool Purge() const {return Delete() == true && (iFlags & pkgDepCache::Purge) == pkgDepCache::Purge; };

       inline bool Keep() const {return Mode == ModeKeep;};
       inline bool Keep() const {return Mode == ModeKeep;};

+      inline bool Protect() const {return (iFlags & Protected) == Protected;};

       inline bool Upgrade() const {return Status > 0 && Mode == ModeInstall;};
       inline bool Upgradable() const {return Status >= 1;};
       inline bool Downgrade() const {return Status < 0 && Mode == ModeInstall;};
       inline bool Upgrade() const {return Status > 0 && Mode == ModeInstall;};
       inline bool Upgradable() const {return Status >= 1;};
       inline bool Downgrade() const {return Status < 0 && Mode == ModeInstall;};


@@ -241,6 +258,7 @@ class pkgDepCache : protected pkgCache::Namespace
       inline bool InstBroken() const {return (DepState & DepInstMin) != DepInstMin;};
       inline bool InstPolicyBroken() const {return (DepState & DepInstPolicy) != DepInstPolicy;};
       inline bool Install() const {return Mode == ModeInstall;};
       inline bool InstBroken() const {return (DepState & DepInstMin) != DepInstMin;};
       inline bool InstPolicyBroken() const {return (DepState & DepInstPolicy) != DepInstPolicy;};
       inline bool Install() const {return Mode == ModeInstall;};

+      inline bool ReInstall() const {return Delete() == false && (iFlags & pkgDepCache::ReInstall) == pkgDepCache::ReInstall;};

       inline VerIterator InstVerIter(pkgCache &Cache)
                 {return VerIterator(Cache,InstallVer);};
       inline VerIterator CandidateVerIter(pkgCache &Cache)
       inline VerIterator InstVerIter(pkgCache &Cache)
                 {return VerIterator(Cache,InstallVer);};
       inline VerIterator CandidateVerIter(pkgCache &Cache)


@@ -255,11 +273,21 @@ class pkgDepCache : protected pkgCache::Namespace
    class Policy
    {
       public:
    class Policy
    {
       public:

-      
+      Policy() {
+         InstallRecommends = _config->FindB("APT::Install-Recommends", false);
+         InstallSuggests = _config->FindB("APT::Install-Suggests", false);
+      }
+

       virtual VerIterator GetCandidateVer(PkgIterator const &Pkg);
       virtual bool IsImportantDep(DepIterator const &Dep);
       virtual VerIterator GetCandidateVer(PkgIterator const &Pkg);
       virtual bool IsImportantDep(DepIterator const &Dep);

-      
+      virtual signed short GetPriority(PkgIterator const &Pkg);
+      virtual signed short GetPriority(PkgFileIterator const &File);
+

       virtual ~Policy() {};
       virtual ~Policy() {};

+
+      private:
+      bool InstallRecommends;
+      bool InstallSuggests;

    };
 
    private:
    };
 
    private:


@@ -313,11 +341,10 @@ class pkgDepCache : protected pkgCache::Namespace
    void Update(PkgIterator const &P);
    
    // Count manipulators
    void Update(PkgIterator const &P);
    
    // Count manipulators

-   void AddSizes(const PkgIterator &Pkg, bool const &Invert = false);
+   void AddSizes(const PkgIterator &Pkg, bool const Invert = false);

    inline void RemoveSizes(const PkgIterator &Pkg) {AddSizes(Pkg, true);};
    inline void RemoveSizes(const PkgIterator &Pkg) {AddSizes(Pkg, true);};

-   void AddSizes(const PkgIterator &Pkg,signed long Mult) __deprecated;
-   void AddStates(const PkgIterator &Pkg,int Add = 1);
-   inline void RemoveStates(const PkgIterator &Pkg) {AddStates(Pkg,-1);};
+   void AddStates(const PkgIterator &Pkg, bool const Invert = false);
+   inline void RemoveStates(const PkgIterator &Pkg) {AddStates(Pkg,true);};

    
    public:
 
    
    public:
 


@@ -326,9 +353,9 @@ class pkgDepCache : protected pkgCache::Namespace
    inline Header &Head() {return *Cache->HeaderP;};
    inline GrpIterator GrpBegin() {return Cache->GrpBegin();};
    inline PkgIterator PkgBegin() {return Cache->PkgBegin();};
    inline Header &Head() {return *Cache->HeaderP;};
    inline GrpIterator GrpBegin() {return Cache->GrpBegin();};
    inline PkgIterator PkgBegin() {return Cache->PkgBegin();};

-   inline GrpIterator FindGrp(string const &Name) {return Cache->FindGrp(Name);};
-   inline PkgIterator FindPkg(string const &Name) {return Cache->FindPkg(Name);};
-   inline PkgIterator FindPkg(string const &Name, string const &Arch) {return Cache->FindPkg(Name, Arch);};
+   inline GrpIterator FindGrp(std::string const &Name) {return Cache->FindGrp(Name);};
+   inline PkgIterator FindPkg(std::string const &Name) {return Cache->FindPkg(Name);};
+   inline PkgIterator FindPkg(std::string const &Name, std::string const &Arch) {return Cache->FindPkg(Name, Arch);};

 
    inline pkgCache &GetCache() {return *Cache;};
    inline pkgVersioningSystem &VS() {return *Cache->VS;};
 
    inline pkgCache &GetCache() {return *Cache;};
    inline pkgVersioningSystem &VS() {return *Cache->VS;};


@@ -363,39 +390,29 @@ class pkgDepCache : protected pkgCache::Namespace
    /** \brief Update the Marked and Garbage fields of all packages.
     *
     *  This routine is implicitly invoked after all state manipulators
    /** \brief Update the Marked and Garbage fields of all packages.
     *
     *  This routine is implicitly invoked after all state manipulators

-    *  and when an ActionGroup is destroyed.  It invokes #MarkRequired
-    *  and #Sweep to do its dirty work.
+    *  and when an ActionGroup is destroyed.  It invokes the private
+    *  MarkRequired() and Sweep() to do its dirty work.

     *
     *  \param rootFunc A predicate that returns \b true for packages
     *  that should be added to the root set.
     */
     *
     *  \param rootFunc A predicate that returns \b true for packages
     *  that should be added to the root set.
     */

-   bool MarkAndSweep(InRootSetFunc &rootFunc)
-   {
-     return MarkRequired(rootFunc) && Sweep();
-   }
-
-   bool MarkAndSweep()
-   {
-     std::auto_ptr<InRootSetFunc> f(GetRootSetFunc());
-     if(f.get() != NULL)
-       return MarkAndSweep(*f.get());
-     else
-       return false;
-   }
+   bool MarkAndSweep(InRootSetFunc &rootFunc);
+   bool MarkAndSweep();

 
    /** \name State Manipulators
     */
    // @{
 
    /** \name State Manipulators
     */
    // @{

-   void MarkKeep(PkgIterator const &Pkg, bool Soft = false,
+   bool MarkKeep(PkgIterator const &Pkg, bool Soft = false,

                 bool FromUser = true, unsigned long Depth = 0);
                 bool FromUser = true, unsigned long Depth = 0);

-   void MarkDelete(PkgIterator const &Pkg, bool Purge = false,
+   bool MarkDelete(PkgIterator const &Pkg, bool MarkPurge = false,

                    unsigned long Depth = 0, bool FromUser = true);
                    unsigned long Depth = 0, bool FromUser = true);

-   void MarkInstall(PkgIterator const &Pkg,bool AutoInst = true,
+   bool MarkInstall(PkgIterator const &Pkg,bool AutoInst = true,

                    unsigned long Depth = 0, bool FromUser = true,
                    bool ForceImportantDeps = false);
                    unsigned long Depth = 0, bool FromUser = true,
                    bool ForceImportantDeps = false);

+   void MarkProtected(PkgIterator const &Pkg) { PkgState[Pkg->ID].iFlags |= Protected; };

 
    void SetReInstall(PkgIterator const &Pkg,bool To);
 
    void SetReInstall(PkgIterator const &Pkg,bool To);

-   void SetCandidateVersion(VerIterator TargetVer, bool const &Pseudo = true);
+   void SetCandidateVersion(VerIterator TargetVer);

    bool SetCandidateRelease(pkgCache::VerIterator TargetVer,
                                std::string const &TargetRel);
    /** Set the candidate version for dependencies too if needed.
    bool SetCandidateRelease(pkgCache::VerIterator TargetVer,
                                std::string const &TargetRel);
    /** Set the candidate version for dependencies too if needed.


@@ -423,16 +440,15 @@ class pkgDepCache : protected pkgCache::Namespace
    /** \return \b true if it's OK for MarkInstall to install
     *  the given package.
     *
    /** \return \b true if it's OK for MarkInstall to install
     *  the given package.
     *

-    *  See the default implementation for a simple example how this
-    *  method can be used.
-    *  Overriding implementations should use the hold-state-flag to cache
-    *  results from previous checks of this package - also it should
-    *  be used if the default resolver implementation is also used to
-    *  ensure that these packages are handled like "normal" dpkg holds.
+    *  The default implementation simply calls all IsInstallOk*
+    *  method mentioned below.
+    *
+    *  Overriding implementations should use the hold-state-flag to
+    *  cache results from previous checks of this package - if possible.

     *
     *  The parameters are the same as in the calling MarkInstall:
     *  \param Pkg       the package that MarkInstall wants to install.
     *
     *  The parameters are the same as in the calling MarkInstall:
     *  \param Pkg       the package that MarkInstall wants to install.

-    *  \param AutoInst  needs a previous MarkInstall this package?
+    *  \param AutoInst  install this and all its dependencies

     *  \param Depth     recursive deep of this Marker call
     *  \param FromUser  was the install requested by the user?
     */
     *  \param Depth     recursive deep of this Marker call
     *  \param FromUser  was the install requested by the user?
     */


@@ -442,20 +458,16 @@ class pkgDepCache : protected pkgCache::Namespace
    /** \return \b true if it's OK for MarkDelete to remove
     *  the given package.
     *
    /** \return \b true if it's OK for MarkDelete to remove
     *  the given package.
     *

-    *  See the default implementation for a simple example how this
-    *  method can be used.
-    *  Overriding implementations should use the hold-state-flag to cache
-    *  results from previous checks of this package - also it should
-    *  be used if the default resolver implementation is also used to
-    *  ensure that these packages are handled like "normal" dpkg holds.
+    *  The default implementation simply calls all IsDeleteOk*
+    *  method mentioned below, see also #IsInstallOk.

     *
     *  The parameters are the same as in the calling MarkDelete:
     *  \param Pkg       the package that MarkDelete wants to remove.
     *
     *  The parameters are the same as in the calling MarkDelete:
     *  \param Pkg       the package that MarkDelete wants to remove.

-    *  \param Purge     should we purge instead of "only" remove?
+    *  \param MarkPurge should we purge instead of "only" remove?

     *  \param Depth     recursive deep of this Marker call
     *  \param FromUser  was the remove requested by the user?
     */
     *  \param Depth     recursive deep of this Marker call
     *  \param FromUser  was the remove requested by the user?
     */

-   virtual bool IsDeleteOk(const PkgIterator &Pkg,bool Purge = false,
+   virtual bool IsDeleteOk(const PkgIterator &Pkg,bool MarkPurge = false,

                            unsigned long Depth = 0, bool FromUser = true);
 
    // read persistent states
                            unsigned long Depth = 0, bool FromUser = true);
 
    // read persistent states


@@ -479,11 +491,20 @@ class pkgDepCache : protected pkgCache::Namespace
    pkgDepCache(pkgCache *Cache,Policy *Plcy = 0);
    virtual ~pkgDepCache();
 
    pkgDepCache(pkgCache *Cache,Policy *Plcy = 0);
    virtual ~pkgDepCache();
 

+   protected:
+   // methods call by IsInstallOk
+   bool IsInstallOkMultiArchSameVersionSynced(PkgIterator const &Pkg,
+        bool const AutoInst, unsigned long const Depth, bool const FromUser);
+   bool IsInstallOkDependenciesSatisfiableByCandidates(PkgIterator const &Pkg,
+      bool const AutoInst, unsigned long const Depth, bool const FromUser);
+
+   // methods call by IsDeleteOk
+   bool IsDeleteOkProtectInstallRequests(PkgIterator const &Pkg,
+        bool const rPurge, unsigned long const Depth, bool const FromUser);
+

    private:
    private:

-   // Helper for Update(OpProgress) to remove pseudoinstalled arch all packages
-   bool RemovePseudoInstalledPkg(PkgIterator &Pkg, std::set<unsigned long> &recheck);
-   bool ReInstallPseudoForGroup(unsigned long const &Grp, std::set<unsigned long> &recheck);
-   bool ReInstallPseudoForGroup(pkgCache::PkgIterator const &P, std::set<unsigned long> &recheck);
+   APT_HIDDEN bool IsModeChangeOk(ModeList const mode, PkgIterator const &Pkg,
+                       unsigned long const Depth, bool const FromUser);

 };
 
 #endif
 };
 
 #endif