X-Git-Url: https://git.saurik.com/apt.git/blobdiff_plain/0432d7310f8b2f356b116774c266744954d1667c..a7307a8727c85b0166339a54fb14ba3812f7a608:/apt-pkg/pkgcachegen.cc

diff --git a/apt-pkg/pkgcachegen.cc b/apt-pkg/pkgcachegen.cc
index a23e965fa..3eeb18cae 100644
--- a/apt-pkg/pkgcachegen.cc
+++ b/apt-pkg/pkgcachegen.cc
@@ -10,10 +10,6 @@
    ##################################################################### */
 									/*}}}*/
 // Include Files							/*{{{*/
-#ifdef __GNUG__
-#pragma implementation "apt-pkg/pkgcachegen.h"
-#endif
-
 #define APT_COMPATIBILITY 986
 
 #include <apt-pkg/pkgcachegen.h>
@@ -25,6 +21,9 @@
 #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 <apti18n.h>
 
@@ -34,7 +33,6 @@
 #include <unistd.h>
 #include <errno.h>
 #include <stdio.h>
-#include <system.h>
 									/*}}}*/
 typedef vector<pkgIndexFile *>::iterator FileIterator;
 
@@ -55,14 +53,16 @@ pkgCacheGenerator::pkgCacheGenerator(DynamicMMap *pMap,OpProgress *Prog) :
    {
       // Setup the map interface..
       Cache.HeaderP = (pkgCache::Header *)Map.Data();
-      Map.RawAllocate(sizeof(pkgCache::Header));
+      if (Map.RawAllocate(sizeof(pkgCache::Header)) == 0 && _error->PendingError() == true)
+	 return;
+
       Map.UsePools(*Cache.HeaderP->Pools,sizeof(Cache.HeaderP->Pools)/sizeof(Cache.HeaderP->Pools[0]));
-      
+
       // Starting header
       *Cache.HeaderP = pkgCache::Header();
       Cache.HeaderP->VerSysName = Map.WriteString(_system->VS->Label);
       Cache.HeaderP->Architecture = Map.WriteString(_config->Find("APT::Architecture"));
-      Cache.ReMap(); 
+      Cache.ReMap();
    }
    else
    {
@@ -125,31 +125,50 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
       string Version = List.Version();
       if (Version.empty() == true)
       {
+	 // we first process the package, then the descriptions
+	 // (this has the bonus that we get MMap error when we run out
+	 //  of MMap space)
+	 if (List.UsePackage(Pkg,pkgCache::VerIterator(Cache)) == false)
+	    return _error->Error(_("Error occurred while processing %s (UsePackage1)"),
+				 PackageName.c_str());
+
  	 // Find the right version to write the description
  	 MD5SumValue CurMd5 = List.Description_md5();
  	 pkgCache::VerIterator Ver = Pkg.VersionList();
  	 map_ptrloc *LastVer = &Pkg->VersionList;
- 	 
-  	 for (; Ver.end() == false; LastVer = &Ver->NextVer, Ver++) 
+
+	 for (; Ver.end() == false; LastVer = &Ver->NextVer, Ver++)
  	 {
  	    pkgCache::DescIterator Desc = Ver.DescriptionList();
  	    map_ptrloc *LastDesc = &Ver->DescriptionList;
-       
- 	    for (; Desc.end() == false; LastDesc = &Desc->NextDesc, Desc++)
- 	       if (MD5SumValue(Desc.md5()) == CurMd5) {
+	    bool duplicate=false;
+
+	    // don't add a new description if we have one for the given
+	    // md5 && language
+	    for ( ; Desc.end() == false; Desc++)
+	       if (MD5SumValue(Desc.md5()) == CurMd5 && 
+	           Desc.LanguageCode() == List.DescriptionLanguage())
+		  duplicate=true;
+	    if(duplicate)
+	       continue;
+	    
+ 	    for (Desc = Ver.DescriptionList();
+		 Desc.end() == false;
+		 LastDesc = &Desc->NextDesc, Desc++)
+	    {
+ 	       if (MD5SumValue(Desc.md5()) == CurMd5) 
+               {
  		  // Add new description
  		  *LastDesc = NewDescription(Desc, List.DescriptionLanguage(), CurMd5, *LastDesc);
  		  Desc->ParentPkg = Pkg.Index();
- 
- 		  if (NewFileDesc(Desc,List) == false)
- 		     return _error->Error(_("Error occured while processing %s (NewFileDesc1)"),PackageName.c_str());
+		  
+		  if ((*LastDesc == 0 && _error->PendingError()) || NewFileDesc(Desc,List) == false)
+ 		     return _error->Error(_("Error occurred while processing %s (NewFileDesc1)"),PackageName.c_str());
  		  break;
  	       }
+	    }
  	 }
- 
-	 if (List.UsePackage(Pkg,pkgCache::VerIterator(Cache)) == false)
-	    return _error->Error(_("Error occurred while processing %s (UsePackage1)"),
-				 PackageName.c_str());
+
 	 continue;
       }
 
@@ -203,7 +222,7 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
       Ver->ParentPkg = Pkg.Index();
       Ver->Hash = Hash;
 
-      if (List.NewVersion(Ver) == false)
+      if ((*LastVer == 0 && _error->PendingError()) || List.NewVersion(Ver) == false)
 	 return _error->Error(_("Error occurred while processing %s (NewVersion1)"),
 			      PackageName.c_str());
 
@@ -235,8 +254,8 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
       *LastDesc = NewDescription(Desc, List.DescriptionLanguage(), List.Description_md5(), *LastDesc);
       Desc->ParentPkg = Pkg.Index();
 
-      if (NewFileDesc(Desc,List) == false)
-	 return _error->Error(_("Error occured while processing %s (NewFileDesc2)"),PackageName.c_str());
+      if ((*LastDesc == 0 && _error->PendingError()) || NewFileDesc(Desc,List) == false)
+	 return _error->Error(_("Error occurred while processing %s (NewFileDesc2)"),PackageName.c_str());
    }
 
    FoundFileDeps |= List.HasFileDeps();
@@ -307,7 +326,7 @@ bool pkgCacheGenerator::MergeFileProvides(ListParser &List)
 // CacheGenerator::NewPackage - Add a new package			/*{{{*/
 // ---------------------------------------------------------------------
 /* This creates a new package structure and adds it to the hash table */
-bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,string Name)
+bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name)
 {
    Pkg = Cache.FindPkg(Name);
    if (Pkg.end() == false)
@@ -371,7 +390,7 @@ bool pkgCacheGenerator::NewFileVer(pkgCache::VerIterator &Ver,
 // ---------------------------------------------------------------------
 /* This puts a version structure in the linked list */
 unsigned long pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver,
-					    string VerStr,
+					    const string &VerStr,
 					    unsigned long Next)
 {
    // Get a structure
@@ -402,15 +421,16 @@ bool pkgCacheGenerator::NewFileDesc(pkgCache::DescIterator &Desc,
    // Get a structure
    unsigned long DescFile = Map.Allocate(sizeof(pkgCache::DescFile));
    if (DescFile == 0)
-      return 0;
-   
+      return false;
+
    pkgCache::DescFileIterator DF(Cache,Cache.DescFileP + DescFile);
    DF->File = CurrentFile - Cache.PkgFileP;
-   
+
    // Link it to the end of the list
    map_ptrloc *Last = &Desc->FileList;
    for (pkgCache::DescFileIterator D = Desc.FileList(); D.end() == false; D++)
       Last = &D->NextFile;
+
    DF->NextFile = *Last;
    *Last = DF.Index();
    
@@ -427,7 +447,8 @@ bool pkgCacheGenerator::NewFileDesc(pkgCache::DescIterator &Desc,
 // ---------------------------------------------------------------------
 /* This puts a description structure in the linked list */
 map_ptrloc pkgCacheGenerator::NewDescription(pkgCache::DescIterator &Desc,
-					    const string &Lang, const MD5SumValue &md5sum,
+					    const string &Lang, 
+                                            const MD5SumValue &md5sum,
 					    map_ptrloc Next)
 {
    // Get a structure
@@ -441,6 +462,8 @@ map_ptrloc pkgCacheGenerator::NewDescription(pkgCache::DescIterator &Desc,
    Desc->ID = Cache.HeaderP->DescriptionCount++;
    Desc->language_code = Map.WriteString(Lang);
    Desc->md5sum = Map.WriteString(md5sum.Value());
+   if (Desc->language_code == 0 || Desc->md5sum == 0)
+      return 0;
 
    return Description;
 }
@@ -450,8 +473,8 @@ map_ptrloc pkgCacheGenerator::NewDescription(pkgCache::DescIterator &Desc,
 /* This creates a dependency element in the tree. It is linked to the
    version and to the package that it is pointing to. */
 bool pkgCacheGenerator::ListParser::NewDepends(pkgCache::VerIterator Ver,
-					       string PackageName,
-					       string Version,
+					       const string &PackageName,
+					       const string &Version,
 					       unsigned int Op,
 					       unsigned int Type)
 {
@@ -515,8 +538,8 @@ bool pkgCacheGenerator::ListParser::NewDepends(pkgCache::VerIterator Ver,
 // ---------------------------------------------------------------------
 /* */
 bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator Ver,
-					        string PackageName,
-						string Version)
+					        const string &PackageName,
+						const string &Version)
 {
    pkgCache &Cache = Owner->Cache;
 
@@ -555,7 +578,7 @@ bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator Ver,
 // ---------------------------------------------------------------------
 /* This is used to select which file is to be associated with all newly
    added versions. The caller is responsible for setting the IMS fields. */
-bool pkgCacheGenerator::SelectFile(string File,string Site,
+bool pkgCacheGenerator::SelectFile(const string &File,const string &Site,
 				   const pkgIndexFile &Index,
 				   unsigned long Flags)
 {
@@ -633,25 +656,31 @@ unsigned long pkgCacheGenerator::WriteUniqString(const char *S,
    return ItemP->String;
 }
 									/*}}}*/
-
 // CheckValidity - Check that a cache is up-to-date			/*{{{*/
 // ---------------------------------------------------------------------
 /* This just verifies that each file in the list of index files exists,
    has matching attributes with the cache and the cache does not have
    any extra files. */
-static bool CheckValidity(string CacheFile, FileIterator Start, 
+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)
+   {
+      if (Debug == true)
+	 std::clog << "CacheFile doesn't exist" << std::endl;
       return false;
-   
+   }
+
    // Map it
    FileFd CacheF(CacheFile,FileFd::ReadOnly);
-   SPtr<MMap> Map = new MMap(CacheF,MMap::Public | MMap::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;
    }
@@ -661,31 +690,56 @@ static bool CheckValidity(string CacheFile, FileIterator 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 (Debug == true)
+	    std::clog << "Has NO packages" << std::endl;
 	 continue;
+      }
     
       if ((*Start)->Exists() == false)
       {
+#if 0 // mvo: we no longer give a message here (Default Sources spec)
 	 _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)
+      {
+	 if (Debug == true)
+	    std::clog << "FindInCache returned end-Pointer" << std::endl;
 	 return false;
+      }
 
       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)
+      {
+	 if (Debug == true)
+	    std::clog << "File with ID" << I << " wasn't visited" << std::endl;
 	 return false;
+      }
    
    if (_error->PendingError() == true)
    {
+      if (Debug == true)
+      {
+	 std::clog << "Validity failed because of pending errors:" << std::endl;
+	 _error->DumpErrors();
+      }
       _error->Discard();
       return false;
    }
@@ -772,7 +826,8 @@ static bool BuildCache(pkgCacheGenerator &Gen,
 bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
 			MMap **OutMap,bool AllowMem)
 {
-   unsigned long MapSize = _config->FindI("APT::Cache-Limit",12*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();
@@ -786,13 +841,13 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
          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..
-   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;
@@ -801,7 +856,9 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
    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());
    
@@ -811,8 +868,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 (Debug == true)
+	 std::clog << "pkgcache.bin is valid - no need to build anything" << std::endl;
       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. */
@@ -826,11 +887,15 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
       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(MMap::Public,MapSize);
+      Map = new DynamicMMap(0,MapSize);
+      if (Debug == true)
+	 std::clog << "Open memory Map (not filebased)" << std::endl;
    }
    
    // Lets try the source cache.
@@ -839,14 +904,18 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
    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);
-      if (SCacheF.Read((unsigned char *)Map->Data() + Map->RawAllocate(SCacheF.Size()),
-		       SCacheF.Size()) == false)
+      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());
-      
+
       // Build the status cache
       pkgCacheGenerator Gen(Map.Get(),&Progress);
       if (_error->PendingError() == true)
@@ -857,6 +926,8 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
    }
    else
    {
+      if (Debug == true)
+	 std::clog << "srcpkgcache.bin is NOT valid - rebuild" << std::endl;
       TotalSize = ComputeSize(Files.begin(),Files.end());
       
       // Build the source cache
@@ -895,6 +966,8 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
 		     Files.begin()+EndOfSource,Files.end()) == false)
 	 return false;
    }
+   if (Debug == true)
+      std::clog << "Caches are ready for shipping" << std::endl;
 
    if (_error->PendingError() == true)
       return false;
@@ -903,7 +976,7 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
       if (CacheF != 0)
       {
 	 delete Map.UnGuard();
-	 *OutMap = new MMap(*CacheF,MMap::Public | MMap::ReadOnly);
+	 *OutMap = new MMap(*CacheF,0);
       }
       else
       {
@@ -919,14 +992,13 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
 /* */
 bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **OutMap)
 {
-   unsigned long MapSize = _config->FindI("APT::Cache-Limit",8*1024*1024);
+   unsigned long MapSize = _config->FindI("APT::Cache-Limit",20*1024*1024);
    vector<pkgIndexFile *> Files;
    unsigned long EndOfSource = Files.size();
    if (_system->AddStatusFiles(Files) == false)
       return false;
    
-   SPtr<DynamicMMap> Map;   
-   Map = new DynamicMMap(MMap::Public,MapSize);
+   SPtr<DynamicMMap> Map = new DynamicMMap(0,MapSize);
    unsigned long CurrentSize = 0;
    unsigned long TotalSize = 0;