fix test/integration/test-apt-ftparchive-cachedb-lp1274466 in travis

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

diff --git a/apt-pkg/pkgcachegen.cc b/apt-pkg/pkgcachegen.cc
index b11ddcf9e084ba766c886fe937a322bab036d500..810f0b0225061597b29e278d0c9c713704940e9c 100644 (file)
--- a/apt-pkg/pkgcachegen.cc
+++ b/apt-pkg/pkgcachegen.cc
@@ -18,20 +18,26 @@
 #include <apt-pkg/progress.h>
 #include <apt-pkg/sourcelist.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/progress.h>
 #include <apt-pkg/sourcelist.h>
 #include <apt-pkg/configuration.h>

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

 #include <apt-pkg/strutl.h>
 #include <apt-pkg/sptr.h>
 #include <apt-pkg/pkgsystem.h>
 #include <apt-pkg/macros.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/metaindex.h>
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/metaindex.h>
 #include <apt-pkg/fileutl.h>

-
+#include <apt-pkg/hashsum_template.h>
+#include <apt-pkg/indexfile.h>
+#include <apt-pkg/md5.h>
+#include <apt-pkg/mmap.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/cacheiterators.h>
+
+#include <stddef.h>
+#include <string.h>
+#include <iostream>
+#include <string>

 #include <vector>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <vector>
 #include <sys/stat.h>
 #include <unistd.h>

-#include <errno.h>
-#include <stdio.h>

 
 #include <apti18n.h>
                                                                        /*}}}*/
 
 #include <apti18n.h>
                                                                        /*}}}*/


@@ -118,11 +124,11 @@ void pkgCacheGenerator::ReMap(void const * const oldMap, void const * const newM
 
    Cache.ReMap(false);
 
 
    Cache.ReMap(false);
 

-   CurrentFile += (pkgCache::PackageFile*) newMap - (pkgCache::PackageFile*) oldMap;
+   CurrentFile += (pkgCache::PackageFile const * const) newMap - (pkgCache::PackageFile const * const) oldMap;

 
    for (size_t i = 0; i < _count(UniqHash); ++i)
       if (UniqHash[i] != 0)
 
    for (size_t i = 0; i < _count(UniqHash); ++i)
       if (UniqHash[i] != 0)

-        UniqHash[i] += (pkgCache::StringItem*) newMap - (pkgCache::StringItem*) oldMap;
+        UniqHash[i] += (pkgCache::StringItem const * const) newMap - (pkgCache::StringItem const * const) oldMap;

 
    for (std::vector<pkgCache::GrpIterator*>::const_iterator i = Dynamic<pkgCache::GrpIterator>::toReMap.begin();
        i != Dynamic<pkgCache::GrpIterator>::toReMap.end(); ++i)
 
    for (std::vector<pkgCache::GrpIterator*>::const_iterator i = Dynamic<pkgCache::GrpIterator>::toReMap.begin();
        i != Dynamic<pkgCache::GrpIterator>::toReMap.end(); ++i)


@@ -296,6 +302,8 @@ bool pkgCacheGenerator::MergeListPackage(ListParser &List, pkgCache::PkgIterator
 
    // Find the right version to write the description
    MD5SumValue CurMd5 = List.Description_md5();
 
    // Find the right version to write the description
    MD5SumValue CurMd5 = List.Description_md5();

+   if (CurMd5.Value().empty() == true || List.Description().empty() == true)
+      return true;

    std::string CurLang = List.DescriptionLanguage();
 
    for (Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
    std::string CurLang = List.DescriptionLanguage();
 
    for (Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)


@@ -348,7 +356,7 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
    map_ptrloc *LastVer = &Pkg->VersionList;
    void const * oldMap = Map.Data();
 
    map_ptrloc *LastVer = &Pkg->VersionList;
    void const * oldMap = Map.Data();
 

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

    if (Ver.end() == false)
    {
       /* We know the list is sorted so we use that fact in the search.
    if (Ver.end() == false)
    {
       /* We know the list is sorted so we use that fact in the search.


@@ -361,7 +369,7 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
         if (Res > 0)
            break;
         // Versionstrings are equal - is hash also equal?
         if (Res > 0)
            break;
         // Versionstrings are equal - is hash also equal?

-        if (Res == 0 && Ver->Hash == Hash)
+        if (Res == 0 && List.SameVersion(Hash, Ver) == true)

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


@@ -390,16 +398,14 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
    }
 
    // Add a new version
    }
 
    // Add a new version

-   map_ptrloc const verindex = NewVersion(Ver,Version,*LastVer);
+   map_ptrloc const verindex = NewVersion(Ver, Version, Pkg.Index(), Hash, *LastVer);

    if (verindex == 0 && _error->PendingError())
       return _error->Error(_("Error occurred while processing %s (%s%d)"),
                           Pkg.Name(), "NewVersion", 1);
 
    if (oldMap != Map.Data())
    if (verindex == 0 && _error->PendingError())
       return _error->Error(_("Error occurred while processing %s (%s%d)"),
                           Pkg.Name(), "NewVersion", 1);
 
    if (oldMap != Map.Data())

-        LastVer += (map_ptrloc*) Map.Data() - (map_ptrloc*) oldMap;
+        LastVer += (map_ptrloc const * const) Map.Data() - (map_ptrloc const * const) oldMap;

    *LastVer = verindex;
    *LastVer = verindex;

-   Ver->ParentPkg = Pkg.Index();
-   Ver->Hash = Hash;

 
    if (unlikely(List.NewVersion(Ver) == false))
       return _error->Error(_("Error occurred while processing %s (%s%d)"),
 
    if (unlikely(List.NewVersion(Ver) == false))
       return _error->Error(_("Error occurred while processing %s (%s%d)"),


@@ -482,7 +488,7 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
 
    /* Record the Description (it is not translated) */
    MD5SumValue CurMd5 = List.Description_md5();
 
    /* Record the Description (it is not translated) */
    MD5SumValue CurMd5 = List.Description_md5();

-   if (CurMd5.Value().empty() == true)
+   if (CurMd5.Value().empty() == true || List.Description().empty() == true)

       return true;
    std::string CurLang = List.DescriptionLanguage();
 
       return true;
    std::string CurLang = List.DescriptionLanguage();
 


@@ -552,12 +558,12 @@ bool pkgCacheGenerator::MergeFileProvides(ListParser &List)
       if (Counter % 100 == 0 && Progress != 0)
         Progress->Progress(List.Offset());
 
       if (Counter % 100 == 0 && Progress != 0)
         Progress->Progress(List.Offset());
 

-      unsigned long Hash = List.VersionHash();
+      unsigned short Hash = List.VersionHash();

       pkgCache::VerIterator Ver = Pkg.VersionList();
       Dynamic<pkgCache::VerIterator> DynVer(Ver);
       for (; Ver.end() == false; ++Ver)
       {
       pkgCache::VerIterator Ver = Pkg.VersionList();
       Dynamic<pkgCache::VerIterator> DynVer(Ver);
       for (; Ver.end() == false; ++Ver)
       {

-        if (Ver->Hash == Hash && Version.c_str() == Ver.VerStr())
+        if (List.SameVersion(Hash, Ver) == true && Version == Ver.VerStr())

         {
            if (List.CollectFileProvides(Cache,Ver) == false)
               return _error->Error(_("Error occurred while processing %s (%s%d)"),
         {
            if (List.CollectFileProvides(Cache,Ver) == false)
               return _error->Error(_("Error occurred while processing %s (%s%d)"),


@@ -595,8 +601,11 @@ bool pkgCacheGenerator::NewGroup(pkgCache::GrpIterator &Grp, const string &Name)
 
    // Insert it into the hash table
    unsigned long const Hash = Cache.Hash(Name);
 
    // Insert it into the hash table
    unsigned long const Hash = Cache.Hash(Name);

-   Grp->Next = Cache.HeaderP->GrpHashTable[Hash];
-   Cache.HeaderP->GrpHashTable[Hash] = Group;
+   map_ptrloc *insertAt = &Cache.HeaderP->GrpHashTable[Hash];
+   while (*insertAt != 0 && strcasecmp(Name.c_str(), Cache.StrP + (Cache.GrpP + *insertAt)->Name) > 0)
+      insertAt = &(Cache.GrpP + *insertAt)->Next;
+   Grp->Next = *insertAt;
+   *insertAt = Group;

 
    Grp->ID = Cache.HeaderP->GroupCount++;
    return true;
 
    Grp->ID = Cache.HeaderP->GroupCount++;
    return true;


@@ -625,11 +634,14 @@ bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name
    // Insert the package into our package list
    if (Grp->FirstPackage == 0) // the group is new
    {
    // Insert the package into our package list
    if (Grp->FirstPackage == 0) // the group is new
    {

+      Grp->FirstPackage = Package;

       // Insert it into the hash table
       unsigned long const Hash = Cache.Hash(Name);
       // Insert it into the hash table
       unsigned long const Hash = Cache.Hash(Name);

-      Pkg->NextPackage = Cache.HeaderP->PkgHashTable[Hash];
-      Cache.HeaderP->PkgHashTable[Hash] = Package;
-      Grp->FirstPackage = Package;
+      map_ptrloc *insertAt = &Cache.HeaderP->PkgHashTable[Hash];
+      while (*insertAt != 0 && strcasecmp(Name.c_str(), Cache.StrP + (Cache.PkgP + *insertAt)->Name) > 0)
+        insertAt = &(Cache.PkgP + *insertAt)->NextPackage;
+      Pkg->NextPackage = *insertAt;
+      *insertAt = Package;

    }
    else // Group the Packages together
    {
    }
    else // Group the Packages together
    {


@@ -762,6 +774,8 @@ bool pkgCacheGenerator::NewFileVer(pkgCache::VerIterator &Ver,
 /* This puts a version structure in the linked list */
 unsigned long pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver,
                                            const string &VerStr,
 /* This puts a version structure in the linked list */
 unsigned long pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver,
                                            const string &VerStr,

+                                           map_ptrloc const ParentPkg,
+                                           unsigned long const Hash,

                                            unsigned long Next)
 {
    // Get a structure
                                            unsigned long Next)
 {
    // Get a structure


@@ -773,12 +787,37 @@ unsigned long pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver,
    Ver = pkgCache::VerIterator(Cache,Cache.VerP + Version);
    //Dynamic<pkgCache::VerIterator> DynV(Ver); // caller MergeListVersion already takes care of it
    Ver->NextVer = Next;
    Ver = pkgCache::VerIterator(Cache,Cache.VerP + Version);
    //Dynamic<pkgCache::VerIterator> DynV(Ver); // caller MergeListVersion already takes care of it
    Ver->NextVer = Next;

+   Ver->ParentPkg = ParentPkg;
+   Ver->Hash = Hash;

    Ver->ID = Cache.HeaderP->VersionCount++;
    Ver->ID = Cache.HeaderP->VersionCount++;

+
+   // try to find the version string in the group for reuse
+   pkgCache::PkgIterator Pkg = Ver.ParentPkg();
+   pkgCache::GrpIterator Grp = Pkg.Group();
+   if (Pkg.end() == false && Grp.end() == false)
+   {
+      for (pkgCache::PkgIterator P = Grp.PackageList(); P.end() == false; P = Grp.NextPkg(P))
+      {
+        if (Pkg == P)
+           continue;
+        for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V)
+        {
+           int const cmp = strcmp(V.VerStr(), VerStr.c_str());
+           if (cmp == 0)
+           {
+              Ver->VerStr = V->VerStr;
+              return Version;
+           }
+           else if (cmp < 0)
+              break;
+        }
+      }
+   }
+   // haven't found the version string, so create

    map_ptrloc const idxVerStr = WriteStringInMap(VerStr);
    if (unlikely(idxVerStr == 0))
       return 0;
    Ver->VerStr = idxVerStr;
    map_ptrloc const idxVerStr = WriteStringInMap(VerStr);
    if (unlikely(idxVerStr == 0))
       return 0;
    Ver->VerStr = idxVerStr;

-   

    return Version;
 }
                                                                        /*}}}*/
    return Version;
 }
                                                                        /*}}}*/


@@ -875,8 +914,8 @@ bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg,
         index = WriteStringInMap(Version);
         if (unlikely(index == 0))
            return false;
         index = WriteStringInMap(Version);
         if (unlikely(index == 0))
            return false;

-        if (oldMap != Map.Data())
-           OldDepLast += (map_ptrloc*) Map.Data() - (map_ptrloc*) oldMap;
+        if (OldDepLast != 0 && oldMap != Map.Data())
+           OldDepLast += (map_ptrloc const * const) Map.Data() - (map_ptrloc const * const) oldMap;

       }
    }
    return NewDepends(Pkg, Ver, index, Op, Type, OldDepLast);
       }
    }
    return NewDepends(Pkg, Ver, index, Op, Type, OldDepLast);


@@ -915,7 +954,7 @@ bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg,
       for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; ++D)
         OldDepLast = &D->NextDepends;
    } else if (oldMap != Map.Data())
       for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; ++D)
         OldDepLast = &D->NextDepends;
    } else if (oldMap != Map.Data())

-      OldDepLast += (map_ptrloc*) Map.Data() - (map_ptrloc*) oldMap;
+      OldDepLast += (map_ptrloc const * const) Map.Data() - (map_ptrloc const * const) oldMap;

 
    Dep->NextDepends = *OldDepLast;
    *OldDepLast = Dep.Index();
 
    Dep->NextDepends = *OldDepLast;
    *OldDepLast = Dep.Index();


@@ -1012,6 +1051,12 @@ bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator &Ver,
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

+bool pkgCacheGenerator::ListParser::SameVersion(unsigned short const Hash,/*{{{*/
+      pkgCache::VerIterator const &Ver)
+{
+   return Hash == Ver->Hash;
+}
+                                                                       /*}}}*/

 // CacheGenerator::SelectFile - Select the current file being parsed   /*{{{*/
 // ---------------------------------------------------------------------
 /* This is used to select which file is to be associated with all newly
 // CacheGenerator::SelectFile - Select the current file being parsed   /*{{{*/
 // ---------------------------------------------------------------------
 /* This is used to select which file is to be associated with all newly


@@ -1092,8 +1137,8 @@ unsigned long pkgCacheGenerator::WriteUniqString(const char *S,
    if (unlikely(idxString == 0))
       return 0;
    if (oldMap != Map.Data()) {
    if (unlikely(idxString == 0))
       return 0;
    if (oldMap != Map.Data()) {

-      Last += (map_ptrloc*) Map.Data() - (map_ptrloc*) oldMap;
-      I += (pkgCache::StringItem*) Map.Data() - (pkgCache::StringItem*) oldMap;
+      Last += (map_ptrloc const * const) Map.Data() - (map_ptrloc const * const) oldMap;
+      I += (pkgCache::StringItem const * const) Map.Data() - (pkgCache::StringItem const * const) oldMap;

    }
    *Last = Item;
 
    }
    *Last = Item;
 


@@ -1216,10 +1261,10 @@ static bool CheckValidity(const string &CacheFile,
 static unsigned long ComputeSize(FileIterator Start,FileIterator End)
 {
    unsigned long TotalSize = 0;
 static unsigned long ComputeSize(FileIterator Start,FileIterator End)
 {
    unsigned long TotalSize = 0;

-   for (; Start != End; ++Start)
+   for (; Start < End; ++Start)

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

-        continue;      
+        continue;

       TotalSize += (*Start)->Size();
    }
    return TotalSize;
       TotalSize += (*Start)->Size();
    }
    return TotalSize;


@@ -1300,7 +1345,7 @@ DynamicMMap* pkgCacheGenerator::CreateDynamicMMap(FileFd *CacheF, unsigned long
    the cache will be stored there. This is pretty much mandetory if you
    are using AllowMem. AllowMem lets the function be run as non-root
    where it builds the cache 'fast' into a memory buffer. */
    the cache will be stored there. This is pretty much mandetory if you
    are using AllowMem. AllowMem lets the function be run as non-root
    where it builds the cache 'fast' into a memory buffer. */

-__deprecated bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
+APT_DEPRECATED bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,

                        MMap **OutMap, bool AllowMem)
    { return pkgCacheGenerator::MakeStatusCache(List, &Progress, OutMap, AllowMem); }
 bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress,
                        MMap **OutMap, bool AllowMem)
    { return pkgCacheGenerator::MakeStatusCache(List, &Progress, OutMap, AllowMem); }
 bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress,


@@ -1501,7 +1546,7 @@ bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress
 // CacheGenerator::MakeOnlyStatusCache - Build only a status files cache/*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // CacheGenerator::MakeOnlyStatusCache - Build only a status files cache/*{{{*/
 // ---------------------------------------------------------------------
 /* */

-__deprecated bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **OutMap)
+APT_DEPRECATED bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **OutMap)

    { return pkgCacheGenerator::MakeOnlyStatusCache(&Progress, OutMap); }
 bool pkgCacheGenerator::MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **OutMap)
 {
    { return pkgCacheGenerator::MakeOnlyStatusCache(&Progress, OutMap); }
 bool pkgCacheGenerator::MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **OutMap)
 {


@@ -1547,7 +1592,7 @@ static bool IsDuplicateDescription(pkgCache::DescIterator Desc,
 }
                                                                        /*}}}*/
 // CacheGenerator::FinishCache                                         /*{{{*/
 }
                                                                        /*}}}*/
 // CacheGenerator::FinishCache                                         /*{{{*/

-bool pkgCacheGenerator::FinishCache(OpProgress *Progress)
+bool pkgCacheGenerator::FinishCache(OpProgress * /*Progress*/)

 {
    return true;
 }
 {
    return true;
 }