merge with debian-sid to get new pl-manpage

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

diff --git a/apt-pkg/pkgcachegen.cc b/apt-pkg/pkgcachegen.cc
index a4ca9dfe4a30469df24a092e530c1c514a135b0c..8187b3950112be32e93a11820744c40986a30ed6 100644 (file)
--- a/apt-pkg/pkgcachegen.cc
+++ b/apt-pkg/pkgcachegen.cc
@@ -22,6 +22,7 @@
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/sptr.h>
 #include <apt-pkg/pkgsystem.h>
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/sptr.h>
 #include <apt-pkg/pkgsystem.h>

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

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


@@ -33,7 +34,6 @@
 #include <unistd.h>
 #include <errno.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <errno.h>
 #include <stdio.h>

-#include <system.h>

                                                                        /*}}}*/
 typedef vector<pkgIndexFile *>::iterator FileIterator;
 
                                                                        /*}}}*/
 typedef vector<pkgIndexFile *>::iterator FileIterator;
 


@@ -115,9 +115,11 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
       /* As we handle Arch all packages as architecture bounded
          we add all information to every (simulated) arch package */
       std::vector<string> genArch;
       /* As we handle Arch all packages as architecture bounded
          we add all information to every (simulated) arch package */
       std::vector<string> genArch;

-      if (List.ArchitectureAll() == true)
+      if (List.ArchitectureAll() == true) {

         genArch = APT::Configuration::getArchitectures();
         genArch = APT::Configuration::getArchitectures();

-      else
+        if (genArch.size() != 1)
+           genArch.push_back("all");
+      } else

         genArch.push_back(List.Architecture());
 
       for (std::vector<string>::const_iterator arch = genArch.begin();
         genArch.push_back(List.Architecture());
 
       for (std::vector<string>::const_iterator arch = genArch.begin();


@@ -187,17 +189,22 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
       pkgCache::VerIterator Ver = Pkg.VersionList();
       map_ptrloc *LastVer = &Pkg->VersionList;
       int Res = 1;
       pkgCache::VerIterator Ver = Pkg.VersionList();
       map_ptrloc *LastVer = &Pkg->VersionList;
       int Res = 1;

+      unsigned long const Hash = List.VersionHash();

       for (; Ver.end() == false; LastVer = &Ver->NextVer, Ver++)
       {
         Res = Cache.VS->CmpVersion(Version,Ver.VerStr());
       for (; Ver.end() == false; LastVer = &Ver->NextVer, Ver++)
       {
         Res = Cache.VS->CmpVersion(Version,Ver.VerStr());

-        if (Res >= 0)
+        // Version is higher as current version - insert here
+        if (Res > 0)
+           break;
+        // Versionstrings are equal - is hash also equal?
+        if (Res == 0 && Ver->Hash == Hash)

            break;
            break;

+        // proceed with the next till we have either the right
+        // or we found another version (which will be lower)

       }
       }

-      
-      /* We already have a version for this item, record that we
-         saw it */
-      unsigned long Hash = List.VersionHash();
-      if (Res == 0 && Ver->Hash == Hash)
+
+      /* We already have a version for this item, record that we saw it */
+      if (Res == 0 && Ver.end() == false && Ver->Hash == Hash)

       {
         if (List.UsePackage(Pkg,Ver) == false)
            return _error->Error(_("Error occurred while processing %s (UsePackage2)"),
       {
         if (List.UsePackage(Pkg,Ver) == false)
            return _error->Error(_("Error occurred while processing %s (UsePackage2)"),


@@ -216,17 +223,6 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
         }
         
         continue;
         }
         
         continue;

-      }      
-
-      // Skip to the end of the same version set.
-      if (Res == 0)
-      {
-        for (; Ver.end() == false; LastVer = &Ver->NextVer, Ver++)
-        {
-           Res = Cache.VS->CmpVersion(Version,Ver.VerStr());
-           if (Res != 0)
-              break;
-        }

       }
 
       // Add a new version
       }
 
       // Add a new version


@@ -531,12 +527,20 @@ bool pkgCacheGenerator::FinishCache(OpProgress &Progress) {
                for (pkgCache::GrpIterator G = GetCache().GrpBegin(); G.end() != true; G++) {
                        string const PkgName = G.Name();
                        for (pkgCache::PkgIterator P = G.PackageList(); P.end() != true; P = G.NextPkg(P)) {
                for (pkgCache::GrpIterator G = GetCache().GrpBegin(); G.end() != true; G++) {
                        string const PkgName = G.Name();
                        for (pkgCache::PkgIterator P = G.PackageList(); P.end() != true; P = G.NextPkg(P)) {

+                               if (strcmp(P.Arch(),"all") == 0)
+                                       continue;
+                               pkgCache::PkgIterator allPkg;

                                for (pkgCache::VerIterator V = P.VersionList(); V.end() != true; V++) {
                                for (pkgCache::VerIterator V = P.VersionList(); V.end() != true; V++) {

-                                       // Arch all packages are "co-installable"
-                                       if (V->MultiArch == pkgCache::Version::All)
-                                               continue;
-                                       string const Arch = V.Arch();
+                                       string const Arch = V.Arch(true);

                                        map_ptrloc *OldDepLast = NULL;
                                        map_ptrloc *OldDepLast = NULL;

+                                       /* MultiArch handling introduces a lot of implicit Dependencies:
+                                          - MultiArch: same → Co-Installable if they have the same version
+                                          - Architecture: all → Need to be Co-Installable for internal reasons
+                                          - All others conflict with all other group members */
+                                       bool const coInstall = (V->MultiArch == pkgCache::Version::All ||
+                                                               V->MultiArch == pkgCache::Version::Same);
+                                       if (V->MultiArch == pkgCache::Version::All && allPkg.end() == true)
+                                               allPkg = G.FindPkg("all");

                                        for (vector<string>::const_iterator A = archs.begin(); A != archs.end(); ++A) {
                                                if (*A == Arch)
                                                        continue;
                                        for (vector<string>::const_iterator A = archs.begin(); A != archs.end(); ++A) {
                                                if (*A == Arch)
                                                        continue;


@@ -546,10 +550,30 @@ bool pkgCacheGenerator::FinishCache(OpProgress &Progress) {
                                                pkgCache::PkgIterator D = G.FindPkg(*A);
                                                if (D.end() == true)
                                                        continue;
                                                pkgCache::PkgIterator D = G.FindPkg(*A);
                                                if (D.end() == true)
                                                        continue;

-                                               // Conflicts: ${self}:other
-                                               NewDepends(D, V, "",
-                                                       pkgCache::Dep::NoOp, pkgCache::Dep::Conflicts,
-                                                       OldDepLast);
+                                               if (coInstall == true) {
+                                                       // Replaces: ${self}:other ( << ${binary:Version})
+                                                       NewDepends(D, V, V.VerStr(),
+                                                                  pkgCache::Dep::Less, pkgCache::Dep::Replaces,
+                                                                  OldDepLast);
+                                                       // Breaks: ${self}:other (!= ${binary:Version})
+                                                       NewDepends(D, V, V.VerStr(),
+                                                                  pkgCache::Dep::Less, pkgCache::Dep::DpkgBreaks,
+                                                                  OldDepLast);
+                                                       NewDepends(D, V, V.VerStr(),
+                                                                  pkgCache::Dep::Greater, pkgCache::Dep::DpkgBreaks,
+                                                                  OldDepLast);
+                                                       if (V->MultiArch == pkgCache::Version::All) {
+                                                               // Depend on ${self}:all which does depend on nothing
+                                                               NewDepends(allPkg, V, V.VerStr(),
+                                                                          pkgCache::Dep::Equals, pkgCache::Dep::Depends,
+                                                                          OldDepLast);
+                                                       }
+                                               } else {
+                                                       // Conflicts: ${self}:other
+                                                       NewDepends(D, V, "",
+                                                                  pkgCache::Dep::NoOp, pkgCache::Dep::Conflicts,
+                                                                  OldDepLast);
+                                               }

                                        }
                                }
                        }
                                        }
                                }
                        }


@@ -651,13 +675,14 @@ bool pkgCacheGenerator::ListParser::NewDepends(pkgCache::VerIterator Ver,
 // ---------------------------------------------------------------------
 /* */
 bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator Ver,
 // ---------------------------------------------------------------------
 /* */
 bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator Ver,

-                                               const string &PackageName,
+                                               const string &PkgName,
+                                               const string &PkgArch,

                                                const string &Version)
 {
    pkgCache &Cache = Owner->Cache;
 
    // We do not add self referencing provides
                                                const string &Version)
 {
    pkgCache &Cache = Owner->Cache;
 
    // We do not add self referencing provides

-   if (unlikely(Ver.ParentPkg().Name() == PackageName))
+   if (Ver.ParentPkg().Name() == PkgName && PkgArch == Ver.Arch(true))

       return true;
    
    // Get a structure
       return true;
    
    // Get a structure


@@ -676,7 +701,7 @@ bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator Ver,
    
    // Locate the target package
    pkgCache::PkgIterator Pkg;
    
    // Locate the target package
    pkgCache::PkgIterator Pkg;

-   if (unlikely(Owner->NewPackage(Pkg,PackageName,string(Ver.Arch())) == false))
+   if (unlikely(Owner->NewPackage(Pkg,PkgName, PkgArch) == false))

       return false;
    
    // Link it to the package
       return false;
    
    // Link it to the package


@@ -777,16 +802,23 @@ unsigned long pkgCacheGenerator::WriteUniqString(const char *S,
 static bool CheckValidity(const string &CacheFile, FileIterator Start, 
                           FileIterator End,MMap **OutMap = 0)
 {
 static bool CheckValidity(const string &CacheFile, FileIterator Start, 
                           FileIterator End,MMap **OutMap = 0)
 {

+   bool const Debug = _config->FindB("Debug::pkgCacheGen", false);

    // No file, certainly invalid
    if (CacheFile.empty() == true || FileExists(CacheFile) == false)
    // No file, certainly invalid
    if (CacheFile.empty() == true || FileExists(CacheFile) == false)

+   {
+      if (Debug == true)
+        std::clog << "CacheFile doesn't exist" << std::endl;

       return false;
       return false;

-   
+   }
+

    // Map it
    FileFd CacheF(CacheFile,FileFd::ReadOnly);
    SPtr<MMap> Map = new MMap(CacheF,0);
    pkgCache Cache(Map);
    if (_error->PendingError() == true || Map->Size() == 0)
    {
    // Map it
    FileFd CacheF(CacheFile,FileFd::ReadOnly);
    SPtr<MMap> Map = new MMap(CacheF,0);
    pkgCache Cache(Map);
    if (_error->PendingError() == true || Map->Size() == 0)
    {

+      if (Debug == true)
+        std::clog << "Errors are pending or Map is empty()" << std::endl;

       _error->Discard();
       return false;
    }
       _error->Discard();
       return false;
    }


@@ -796,9 +828,15 @@ static bool CheckValidity(const string &CacheFile, FileIterator Start,
    SPtrArray<bool> Visited = new bool[Cache.HeaderP->PackageFileCount];
    memset(Visited,0,sizeof(*Visited)*Cache.HeaderP->PackageFileCount);
    for (; Start != End; Start++)
    SPtrArray<bool> Visited = new bool[Cache.HeaderP->PackageFileCount];
    memset(Visited,0,sizeof(*Visited)*Cache.HeaderP->PackageFileCount);
    for (; Start != End; Start++)

-   {      
+   {
+      if (Debug == true)
+        std::clog << "Checking PkgFile " << (*Start)->Describe() << ": ";

       if ((*Start)->HasPackages() == false)
       if ((*Start)->HasPackages() == false)

+      {
+         if (Debug == true)
+           std::clog << "Has NO packages" << std::endl;

         continue;
         continue;

+      }

     
       if ((*Start)->Exists() == false)
       {
     
       if ((*Start)->Exists() == false)
       {


@@ -806,23 +844,40 @@ static bool CheckValidity(const string &CacheFile, FileIterator Start,
         _error->WarningE("stat",_("Couldn't stat source package list %s"),
                          (*Start)->Describe().c_str());
 #endif
         _error->WarningE("stat",_("Couldn't stat source package list %s"),
                          (*Start)->Describe().c_str());
 #endif

+         if (Debug == true)
+           std::clog << "file doesn't exist" << std::endl;

         continue;
       }
 
       // FindInCache is also expected to do an IMS check.
       pkgCache::PkgFileIterator File = (*Start)->FindInCache(Cache);
       if (File.end() == true)
         continue;
       }
 
       // FindInCache is also expected to do an IMS check.
       pkgCache::PkgFileIterator File = (*Start)->FindInCache(Cache);
       if (File.end() == true)

+      {
+        if (Debug == true)
+           std::clog << "FindInCache returned end-Pointer" << std::endl;

         return false;
         return false;

+      }

 
       Visited[File->ID] = true;
 
       Visited[File->ID] = true;

+      if (Debug == true)
+        std::clog << "with ID " << File->ID << " is valid" << std::endl;

    }
    
    for (unsigned I = 0; I != Cache.HeaderP->PackageFileCount; I++)
       if (Visited[I] == false)
    }
    
    for (unsigned I = 0; I != Cache.HeaderP->PackageFileCount; I++)
       if (Visited[I] == false)

+      {
+        if (Debug == true)
+           std::clog << "File with ID" << I << " wasn't visited" << std::endl;

         return false;
         return false;

+      }

    
    if (_error->PendingError() == true)
    {
    
    if (_error->PendingError() == true)
    {

+      if (Debug == true)
+      {
+        std::clog << "Validity failed because of pending errors:" << std::endl;
+        _error->DumpErrors();
+      }

       _error->Discard();
       return false;
    }
       _error->Discard();
       return false;
    }


@@ -909,7 +964,8 @@ static bool BuildCache(pkgCacheGenerator &Gen,
 bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
                        MMap **OutMap,bool AllowMem)
 {
 bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
                        MMap **OutMap,bool AllowMem)
 {

-   unsigned long MapSize = _config->FindI("APT::Cache-Limit",24*1024*1024);
+   bool const Debug = _config->FindB("Debug::pkgCacheGen", false);
+   unsigned long const MapSize = _config->FindI("APT::Cache-Limit",24*1024*1024);

    
    vector<pkgIndexFile *> Files;
    for (vector<metaIndex *>::const_iterator i = List.begin();
    
    vector<pkgIndexFile *> Files;
    for (vector<metaIndex *>::const_iterator i = List.begin();


@@ -923,13 +979,13 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
          Files.push_back (*j);
    }
    
          Files.push_back (*j);
    }
    

-   unsigned long EndOfSource = Files.size();
+   unsigned long const EndOfSource = Files.size();

    if (_system->AddStatusFiles(Files) == false)
       return false;
 
    // Decide if we can write to the files..
    if (_system->AddStatusFiles(Files) == false)
       return false;
 
    // Decide if we can write to the files..

-   string CacheFile = _config->FindFile("Dir::Cache::pkgcache");
-   string SrcCacheFile = _config->FindFile("Dir::Cache::srcpkgcache");
+   string const CacheFile = _config->FindFile("Dir::Cache::pkgcache");
+   string const SrcCacheFile = _config->FindFile("Dir::Cache::srcpkgcache");

    
    // Decide if we can write to the cache
    bool Writeable = false;
    
    // Decide if we can write to the cache
    bool Writeable = false;


@@ -938,7 +994,9 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
    else
       if (SrcCacheFile.empty() == false)
         Writeable = access(flNotFile(SrcCacheFile).c_str(),W_OK) == 0;
    else
       if (SrcCacheFile.empty() == false)
         Writeable = access(flNotFile(SrcCacheFile).c_str(),W_OK) == 0;

-   
+   if (Debug == true)
+      std::clog << "Do we have write-access to the cache files? " << (Writeable ? "YES" : "NO") << std::endl;
+

    if (Writeable == false && AllowMem == false && CacheFile.empty() == false)
       return _error->Error(_("Unable to write to %s"),flNotFile(CacheFile).c_str());
    
    if (Writeable == false && AllowMem == false && CacheFile.empty() == false)
       return _error->Error(_("Unable to write to %s"),flNotFile(CacheFile).c_str());
    


@@ -948,8 +1006,12 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
    if (CheckValidity(CacheFile,Files.begin(),Files.end(),OutMap) == true)
    {
       Progress.OverallProgress(1,1,1,_("Reading package lists"));
    if (CheckValidity(CacheFile,Files.begin(),Files.end(),OutMap) == true)
    {
       Progress.OverallProgress(1,1,1,_("Reading package lists"));

+      if (Debug == true)
+        std::clog << "pkgcache.bin is valid - no need to build anything" << std::endl;

       return true;
    }
       return true;
    }

+   else if (Debug == true)
+        std::clog << "pkgcache.bin is NOT valid" << std::endl;

    
    /* At this point we know we need to reconstruct the package cache,
       begin. */
    
    /* At this point we know we need to reconstruct the package cache,
       begin. */


@@ -963,11 +1025,15 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
       Map = new DynamicMMap(*CacheF,MMap::Public,MapSize);
       if (_error->PendingError() == true)
         return false;
       Map = new DynamicMMap(*CacheF,MMap::Public,MapSize);
       if (_error->PendingError() == true)
         return false;

+      if (Debug == true)
+        std::clog << "Open filebased MMap" << std::endl;

    }
    else
    {
       // Just build it in memory..
       Map = new DynamicMMap(0,MapSize);
    }
    else
    {
       // Just build it in memory..
       Map = new DynamicMMap(0,MapSize);

+      if (Debug == true)
+        std::clog << "Open memory Map (not filebased)" << std::endl;

    }
    
    // Lets try the source cache.
    }
    
    // Lets try the source cache.


@@ -976,16 +1042,18 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
    if (CheckValidity(SrcCacheFile,Files.begin(),
                     Files.begin()+EndOfSource) == true)
    {
    if (CheckValidity(SrcCacheFile,Files.begin(),
                     Files.begin()+EndOfSource) == true)
    {

+      if (Debug == true)
+        std::clog << "srcpkgcache.bin is valid - populate MMap with it." << std::endl;

       // Preload the map with the source cache
       FileFd SCacheF(SrcCacheFile,FileFd::ReadOnly);
       // Preload the map with the source cache
       FileFd SCacheF(SrcCacheFile,FileFd::ReadOnly);

-      unsigned long alloc = Map->RawAllocate(SCacheF.Size());
+      unsigned long const alloc = Map->RawAllocate(SCacheF.Size());

       if ((alloc == 0 && _error->PendingError())
                || SCacheF.Read((unsigned char *)Map->Data() + alloc,
                                SCacheF.Size()) == false)
         return false;
 
       TotalSize = ComputeSize(Files.begin()+EndOfSource,Files.end());
       if ((alloc == 0 && _error->PendingError())
                || SCacheF.Read((unsigned char *)Map->Data() + alloc,
                                SCacheF.Size()) == false)
         return false;
 
       TotalSize = ComputeSize(Files.begin()+EndOfSource,Files.end());

-      
+

       // Build the status cache
       pkgCacheGenerator Gen(Map.Get(),&Progress);
       if (_error->PendingError() == true)
       // Build the status cache
       pkgCacheGenerator Gen(Map.Get(),&Progress);
       if (_error->PendingError() == true)


@@ -999,6 +1067,8 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
    }
    else
    {
    }
    else
    {

+      if (Debug == true)
+        std::clog << "srcpkgcache.bin is NOT valid - rebuild" << std::endl;

       TotalSize = ComputeSize(Files.begin(),Files.end());
       
       // Build the source cache
       TotalSize = ComputeSize(Files.begin(),Files.end());
       
       // Build the source cache


@@ -1040,6 +1110,8 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
       // FIXME: move me to a better place
       Gen.FinishCache(Progress);
    }
       // FIXME: move me to a better place
       Gen.FinishCache(Progress);
    }

+   if (Debug == true)
+      std::clog << "Caches are ready for shipping" << std::endl;

 
    if (_error->PendingError() == true)
       return false;
 
    if (_error->PendingError() == true)
       return false;