don't change owner/perms/times through file:// symlinks

[apt.git] / ftparchive / cachedb.cc

diff --git a/ftparchive/cachedb.cc b/ftparchive/cachedb.cc
index be54ea62c1128ec83cc4d547c142a1b50922418d..868029abde4d6904785772bc7cb753a7e3dbd19e 100644 (file)
--- a/ftparchive/cachedb.cc
+++ b/ftparchive/cachedb.cc
@@ -34,6 +34,20 @@
 #include <apti18n.h>
                                                                        /*}}}*/
 
 #include <apti18n.h>
                                                                        /*}}}*/
 

+CacheDB::CacheDB(std::string const &DB)
+   : Dbp(0), Fd(NULL), DebFile(0)
+{
+   TmpKey[0]='\0';
+   ReadyDB(DB);
+}
+
+CacheDB::~CacheDB()
+{
+   ReadyDB();
+   delete DebFile;
+   CloseFile();
+}
+

 // CacheDB::ReadyDB - Ready the DB2                                    /*{{{*/
 // ---------------------------------------------------------------------
 /* This opens the DB2 file for caching package information */
 // CacheDB::ReadyDB - Ready the DB2                                    /*{{{*/
 // ---------------------------------------------------------------------
 /* This opens the DB2 file for caching package information */


@@ -88,7 +102,7 @@ bool CacheDB::ReadyDB(std::string const &DB)
           return _error->Error(_("Unable to open DB file %s: %s"),DB.c_str(), db_strerror(err));
       }
    }
           return _error->Error(_("Unable to open DB file %s: %s"),DB.c_str(), db_strerror(err));
       }
    }

-   
+

    DBFile = DB;
    DBLoaded = true;
    return true;
    DBFile = DB;
    DBLoaded = true;
    return true;


@@ -174,6 +188,45 @@ bool CacheDB::GetFileStat(bool const &doStat)
    CurStat.mtime = htonl(St.st_mtime);
    CurStat.Flags |= FlSize;
    
    CurStat.mtime = htonl(St.st_mtime);
    CurStat.Flags |= FlSize;
    

+   return true;
+}
+                                                                       /*}}}*/
+// CacheDB::GetCurStatCompatOldFormat                                  /*{{{*/
+// ---------------------------------------------------------------------
+/* Read the old (32bit FileSize) StateStore format from disk */
+bool CacheDB::GetCurStatCompatOldFormat()
+{
+   InitQueryStats();
+   Data.data = &CurStatOldFormat;
+   Data.flags = DB_DBT_USERMEM;
+   Data.ulen = sizeof(CurStatOldFormat);
+   if (Get() == false)
+   {
+      CurStat.Flags = 0;
+   } else {
+      CurStat.Flags = CurStatOldFormat.Flags;
+      CurStat.mtime = CurStatOldFormat.mtime;
+      CurStat.FileSize = CurStatOldFormat.FileSize;
+      memcpy(CurStat.MD5, CurStatOldFormat.MD5, sizeof(CurStat.MD5));
+      memcpy(CurStat.SHA1, CurStatOldFormat.SHA1, sizeof(CurStat.SHA1));
+      memcpy(CurStat.SHA256, CurStatOldFormat.SHA256, sizeof(CurStat.SHA256));
+   }
+   return true;
+}
+                                                                       /*}}}*/
+// CacheDB::GetCurStatCompatOldFormat                                  /*{{{*/
+// ---------------------------------------------------------------------
+/* Read the new (64bit FileSize) StateStore format from disk */
+bool CacheDB::GetCurStatCompatNewFormat()
+{
+   InitQueryStats();
+   Data.data = &CurStat;
+   Data.flags = DB_DBT_USERMEM;
+   Data.ulen = sizeof(CurStat);
+   if (Get() == false)
+   {
+      CurStat.Flags = 0;
+   }

    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/


@@ -187,19 +240,29 @@ bool CacheDB::GetCurStat()
    
    if (DBLoaded)
    {
    
    if (DBLoaded)
    {

-      /* First see if there is anything about it
-         in the database */
-      
-      /* Get the flags (and mtime) */
+      // do a first query to just get the size of the data on disk

       InitQueryStats();
       InitQueryStats();

-      // Ensure alignment of the returned structure

       Data.data = &CurStat;
       Data.data = &CurStat;

-      Data.ulen = sizeof(CurStat);

       Data.flags = DB_DBT_USERMEM;
       Data.flags = DB_DBT_USERMEM;

-      if (Get() == false)
+      Data.ulen = 0;
+      Get();
+
+      if (Data.size == 0)
+      {
+         // nothing needs to be done, we just have not data for this deb
+      }
+      // check if the record is written in the old format (32bit filesize)
+      else if(Data.size == sizeof(CurStatOldFormat))

       {
       {

-        CurStat.Flags = 0;
-      }      
+         GetCurStatCompatOldFormat();
+      }
+      else if(Data.size == sizeof(CurStat))
+      {
+         GetCurStatCompatNewFormat();
+      } else {
+         return _error->Error("Cache record size mismatch (%ul)", Data.size);
+      }
+

       CurStat.Flags = ntohl(CurStat.Flags);
       CurStat.FileSize = ntohl(CurStat.FileSize);
    }      
       CurStat.Flags = ntohl(CurStat.Flags);
       CurStat.FileSize = ntohl(CurStat.FileSize);
    }      


@@ -260,12 +323,12 @@ bool CacheDB::LoadSource()                                                /*{{{*/
    if (Dsc.Read(FileName) == false)
       return false;
 
    if (Dsc.Read(FileName) == false)
       return false;
 

-   if (Dsc.Data == 0)
+   if (Dsc.Length == 0)

       return _error->Error(_("Failed to read .dsc"));
       return _error->Error(_("Failed to read .dsc"));

-   
+

    // Write back the control information
    InitQuerySource();
    // Write back the control information
    InitQuerySource();

-   if (Put(Dsc.Data, Dsc.Length) == true)
+   if (Put(Dsc.Data.c_str(), Dsc.Length) == true)

       CurStat.Flags |= FlSource;
 
    return true;
       CurStat.Flags |= FlSource;
 
    return true;


@@ -371,7 +434,24 @@ static void hex2bytes(uint8_t *bytes, const char *hex, int length) {
 }
 bool CacheDB::GetHashes(bool const GenOnly, unsigned int const DoHashes)
 {
 }
 bool CacheDB::GetHashes(bool const GenOnly, unsigned int const DoHashes)
 {

-   unsigned int FlHashes = DoHashes & (Hashes::MD5SUM | Hashes::SHA1SUM | Hashes::SHA256SUM | Hashes::SHA512SUM);
+   unsigned int notCachedHashes = 0;
+   if ((CurStat.Flags & FlMD5) != FlMD5)
+   {
+      notCachedHashes = notCachedHashes | Hashes::MD5SUM;
+   }
+   if ((CurStat.Flags & FlSHA1) != FlSHA1)
+   {
+      notCachedHashes = notCachedHashes | Hashes::SHA1SUM;
+   }
+   if ((CurStat.Flags & FlSHA256) != FlSHA256)
+   {
+      notCachedHashes = notCachedHashes | Hashes::SHA256SUM;
+   }
+   if ((CurStat.Flags & FlSHA512) != FlSHA512)
+   {
+      notCachedHashes = notCachedHashes | Hashes::SHA512SUM;
+   }
+   unsigned int FlHashes = DoHashes & notCachedHashes;

    HashesList.clear();
 
    if (FlHashes != 0)
    HashesList.clear();
 
    if (FlHashes != 0)


@@ -379,8 +459,8 @@ bool CacheDB::GetHashes(bool const GenOnly, unsigned int const DoHashes)
       if (OpenFile() == false)
         return false;
 
       if (OpenFile() == false)
         return false;
 

-      Hashes hashes;
-      if (Fd->Seek(0) == false || hashes.AddFD(*Fd, CurStat.FileSize, FlHashes) == false)
+      Hashes hashes(FlHashes);
+      if (Fd->Seek(0) == false || hashes.AddFD(*Fd, CurStat.FileSize) == false)

         return false;
 
       HashStringList hl = hashes.GetHashStringList();
         return false;
 
       HashStringList hl = hashes.GetHashStringList();


@@ -411,6 +491,10 @@ bool CacheDB::GetHashes(bool const GenOnly, unsigned int const DoHashes)
            hex2bytes(CurStat.MD5, hs->HashValue().data(), sizeof(CurStat.MD5));
            CurStat.Flags |= FlMD5;
         }
            hex2bytes(CurStat.MD5, hs->HashValue().data(), sizeof(CurStat.MD5));
            CurStat.Flags |= FlMD5;
         }

+        else if (strcasecmp(hs->HashType().c_str(), "Checksum-FileSize") == 0)
+        {
+           // we store it in a different field already
+        }

         else
            return _error->Error("Got unknown unrequested hashtype %s", hs->HashType().c_str());
       }
         else
            return _error->Error("Got unknown unrequested hashtype %s", hs->HashType().c_str());
       }


@@ -418,10 +502,15 @@ bool CacheDB::GetHashes(bool const GenOnly, unsigned int const DoHashes)
    if (GenOnly == true)
       return true;
 
    if (GenOnly == true)
       return true;
 

-   return HashesList.push_back(HashString("MD5Sum", bytes2hex(CurStat.MD5, sizeof(CurStat.MD5)))) &&
-      HashesList.push_back(HashString("SHA1", bytes2hex(CurStat.SHA1, sizeof(CurStat.SHA1)))) &&
-      HashesList.push_back(HashString("SHA256", bytes2hex(CurStat.SHA256, sizeof(CurStat.SHA256)))) &&
-      HashesList.push_back(HashString("SHA512", bytes2hex(CurStat.SHA512, sizeof(CurStat.SHA512))));
+   bool ret = true;
+#define PUSH_BACK_HASH(FLAG, TYPE, VALUE) \
+   if ((CurStat.Flags & FLAG) == FLAG) \
+      ret &= HashesList.push_back(HashString(TYPE, bytes2hex(VALUE, sizeof(VALUE))));
+   PUSH_BACK_HASH(FlMD5, "MD5Sum", CurStat.MD5);
+   PUSH_BACK_HASH(FlSHA1, "SHA1", CurStat.SHA1);
+   PUSH_BACK_HASH(FlSHA256, "SHA256", CurStat.SHA256);
+   PUSH_BACK_HASH(FlSHA512, "SHA512", CurStat.SHA512);
+   return ret;

 }
                                                                        /*}}}*/
 // CacheDB::Finish - Write back the cache structure                    /*{{{*/
 }
                                                                        /*}}}*/
 // CacheDB::Finish - Write back the cache structure                    /*{{{*/