]> git.saurik.com Git - apt.git/commitdiff
The 'not dead yet' release
authorMichael Vogt <michael.vogt@ubuntu.com>
Tue, 21 Jul 2009 16:31:36 +0000 (18:31 +0200)
committerMichael Vogt <michael.vogt@ubuntu.com>
Tue, 21 Jul 2009 16:31:36 +0000 (18:31 +0200)
* add hook for MarkInstall and MarkDelete (closes: #470035)
* add the various foldmarkers in apt-pkg & cmdline (no code change)
* versions with a pin of -1 shouldn't be a candidate (Closes: #355237)
* prefer mmap as memory allocator in MMap instead of a static char
  array which can (at least in theory) grow dynamic
* eliminate (hopefully all) segfaults in pkgcachegen.cc and mmap.cc
  which can arise if cache doesn't fit into the mmap (Closes: #535218)
* display warnings instead of errors if the parts dirs doesn't exist
* honor the dpkg hold state in new Marker hooks (closes: #64141)

12 files changed:
1  2 
apt-pkg/acquire.cc
apt-pkg/algorithms.cc
apt-pkg/cacheiterators.h
apt-pkg/cdrom.cc
apt-pkg/contrib/hashes.cc
apt-pkg/contrib/mmap.cc
apt-pkg/indexcopy.cc
apt-pkg/indexrecords.cc
cmdline/apt-cache.cc
debian/changelog
doc/apt-get.8.xml
doc/examples/configure-index

diff --combined apt-pkg/acquire.cc
index c1f6581e2c4cb066572309e355797c8c4ad9d670,68ff393d05cb83d37492aa125aaaa571934aaef5..74510ae21aaaef46ff13aeb9578c8f4b295c99f7
@@@ -24,8 -24,7 +24,8 @@@
  
  #include <iostream>
  #include <sstream>
 -    
 +#include <stdio.h>
 +
  #include <dirent.h>
  #include <sys/time.h>
  #include <errno.h>
@@@ -485,7 -484,7 +485,7 @@@ double pkgAcquire::PartialPresent(
         Total += (*I)->PartialSize;
     return Total;
  }
+                                                                       /*}}}*/
  // Acquire::UriBegin - Start iterator for the uri list                        /*{{{*/
  // ---------------------------------------------------------------------
  /* */
@@@ -502,7 -501,6 +502,6 @@@ pkgAcquire::UriIterator pkgAcquire::Uri
     return UriIterator(0);
  }
                                                                        /*}}}*/
  // Acquire::MethodConfig::MethodConfig - Constructor                  /*{{{*/
  // ---------------------------------------------------------------------
  /* */
@@@ -516,7 -514,6 +515,6 @@@ pkgAcquire::MethodConfig::MethodConfig(
     Next = 0;
  }
                                                                        /*}}}*/
  // Queue::Queue - Constructor                                         /*{{{*/
  // ---------------------------------------------------------------------
  /* */
@@@ -621,7 -618,7 +619,7 @@@ bool pkgAcquire::Queue::Startup(
           added other source retry to have cycle maintain a pipeline depth
           on its own. */
        if (Cnf->Pipeline == true)
 -       MaxPipeDepth = 1000;
 +       MaxPipeDepth = _config->FindI("Acquire::Max-Pipeline-Depth",10);
        else
         MaxPipeDepth = 1;
     }
@@@ -728,7 -725,6 +726,6 @@@ void pkgAcquire::Queue::Bump(
     Cycle();
  }
                                                                        /*}}}*/
  // AcquireStatus::pkgAcquireStatus - Constructor                      /*{{{*/
  // ---------------------------------------------------------------------
  /* */
diff --combined apt-pkg/algorithms.cc
index 1fd3d39a4dd9ad967decfaf2203fa2bf429bb878,a30a02edb86bf76d4a4bc4d9141cbfc8276a089d..34da745dea5ac67a2b25c1e83d7478e96f0a7a27
@@@ -442,7 -442,6 +442,6 @@@ bool pkgMinimizeUpgrade(pkgDepCache &Ca
     return true;
  }
                                                                        /*}}}*/
  // ProblemResolver::pkgProblemResolver - Constructor                  /*{{{*/
  // ---------------------------------------------------------------------
  /* */
@@@ -501,7 -500,6 +500,7 @@@ void pkgProblemResolver::MakeScores(
     signed short PrioEssentials = _config->FindI("pkgProblemResolver::Scores::Essentials",100);
     signed short PrioInstalledAndNotObsolete = _config->FindI("pkgProblemResolver::Scores::NotObsolete",1);
     signed short PrioDepends = _config->FindI("pkgProblemResolver::Scores::Depends",1);
 +   signed short PrioRecommends = _config->FindI("pkgProblemResolver::Scores::Recommends",1);
     signed short AddProtected = _config->FindI("pkgProblemResolver::Scores::AddProtected",10000);
     signed short AddEssential = _config->FindI("pkgProblemResolver::Scores::AddEssential",5000);
  
           << "  Essentials => " << PrioEssentials << endl
           << "  InstalledAndNotObsolete => " << PrioInstalledAndNotObsolete << endl
           << "  Depends => " << PrioDepends << endl
 +         << "  Recommends => " << PrioRecommends << endl
           << "  AddProtected => " << AddProtected << endl
           << "  AddEssential => " << AddEssential << endl;
  
        
        for (pkgCache::DepIterator D = Cache[I].InstVerIter(Cache).DependsList(); D.end() == false; D++)
        {
 -       if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
 -          Scores[D.TargetPkg()->ID]+= PrioDepends;
 +       if (D->Type == pkgCache::Dep::Depends || 
 +           D->Type == pkgCache::Dep::PreDepends)
 +          Scores[D.TargetPkg()->ID] += PrioDepends;
 +       else if (D->Type == pkgCache::Dep::Recommends)
 +          Scores[D.TargetPkg()->ID] += PrioRecommends;
        }
     }   
     
        {
         // Only do it for the install version
         if ((pkgCache::Version *)D.ParentVer() != Cache[D.ParentPkg()].InstallVer ||
 -           (D->Type != pkgCache::Dep::Depends && D->Type != pkgCache::Dep::PreDepends))
 +           (D->Type != pkgCache::Dep::Depends && 
 +            D->Type != pkgCache::Dep::PreDepends &&
 +            D->Type != pkgCache::Dep::Recommends))
            continue;    
         
         Scores[I->ID] += abs(OldScores[D.ParentPkg()->ID]);
@@@ -992,26 -984,11 +991,11 @@@ bool pkgProblemResolver::Resolve(bool B
                        // Consider other options
                        if (InOr == false)
                        {
-                          if (Cache.AutoInstOk(I, Cache[I].CandidateVerIter(Cache),Start) == true)
-                          {
-                             if (Debug == true)
-                                clog << "  Removing " << I.Name() << " rather than change " << Start.TargetPkg().Name() << endl;
-                             Cache.MarkDelete(I);
-                             if (Counter > 1)
-                             {
-                                if (Scores[Pkg->ID] > Scores[I->ID])
-                                   Scores[I->ID] = Scores[Pkg->ID];
-                             }
-                          } else {
-                             /* The dependency of the TargetPkg would be satisfiable with I but it is
-                                forbidden to install I automatical, so anything we can do is hold
-                                back the TargetPkg.
-                             */
-                             if (Debug == true)
-                                clog << "  Hold back " << Start.TargetPkg().Name() <<
-                                       " rather than change denied AutoInstall " << I.Name() << endl;
-                             Cache.MarkKeep(Start.TargetPkg());
-                          }
+                          if (Debug == true)
+                             clog << "  Removing " << I.Name() << " rather than change " << Start.TargetPkg().Name() << endl;
+                          Cache.MarkDelete(I);
+                          if (Counter > 1 && Scores[Pkg->ID] > Scores[I->ID])
+                             Scores[I->ID] = Scores[Pkg->ID];
                        }
                     }
                  }
@@@ -1330,7 -1307,6 +1314,6 @@@ void pkgProblemResolver::InstallProtect
     }   
  }
                                                                        /*}}}*/
  // PrioSortList - Sort a list of versions by priority                 /*{{{*/
  // ---------------------------------------------------------------------
  /* This is ment to be used in conjunction with AllTargets to get a list 
@@@ -1361,7 -1337,6 +1344,6 @@@ void pkgPrioSortList(pkgCache &Cache,pk
     qsort(List,Count,sizeof(*List),PrioComp);
  }
                                                                        /*}}}*/
  // CacheFile::ListUpdate - update the cache files                     /*{{{*/
  // ---------------------------------------------------------------------
  /* This is a simple wrapper to update the cache. it will fetch stuff
diff --combined apt-pkg/cacheiterators.h
index af21681edf2f2dce79b455b3f0e09c8ce682dedb,3d35e42982b99e98b728a328ff71aea528e417d2..28466cd406aae39c5c08eed2c735229a3fef40cd
@@@ -32,7 -32,7 +32,7 @@@
  #define PKGLIB_CACHEITERATORS_H
  
  
- // Package Iterator
+ // Package Iterator                                                   /*{{{*/
  class pkgCache::PkgIterator
  {
     friend class pkgCache;
@@@ -96,8 -96,8 +96,8 @@@
     };
     inline PkgIterator() : Pkg(0), Owner(0), HashIndex(0) {};
  };
- // Version Iterator
+                                                                       /*}}}*/
+ // Version Iterator                                                   /*{{{*/
  class pkgCache::VerIterator
  {
     Version *Ver;
     // Iteration
     void operator ++(int) {if (Ver != Owner->VerP) Ver = Owner->VerP + Ver->NextVer;};
     inline void operator ++() {operator ++(0);};
 -   inline bool end() const {return Owner == NULL || (Ver == Owner->VerP?true:false);};
 +   inline bool end() const {return Owner == 0 || (Ver == Owner->VerP?true:false);};
     inline void operator =(const VerIterator &B) {Ver = B.Ver; Owner = B.Owner;};
     
     // Comparison
         Ver = Owner.VerP;
     };
  };
- // Description Iterator
+                                                                       /*}}}*/
+ // Description Iterator                                                       /*{{{*/
  class pkgCache::DescIterator
  {
     Description *Desc;
     // Iteration
     void operator ++(int) {if (Desc != Owner->DescP) Desc = Owner->DescP + Desc->NextDesc;};
     inline void operator ++() {operator ++(0);};
 -   inline bool end() const {return Desc == Owner->DescP?true:false;};
 +   inline bool end() const {return Owner == 0 || Desc == Owner->DescP?true:false;};
     inline void operator =(const DescIterator &B) {Desc = B.Desc; Owner = B.Owner;};
     
     // Comparison
         Desc = Owner.DescP;
     };
  };
- // Dependency iterator
+                                                                       /*}}}*/
+ // Dependency iterator                                                        /*{{{*/
  class pkgCache::DepIterator
  {
     Dependency *Dep;
     };
     inline DepIterator() : Dep(0), Type(DepVer), Owner(0) {};
  };
- // Provides iterator
+                                                                       /*}}}*/
+ // Provides iterator                                                  /*{{{*/
  class pkgCache::PrvIterator
  {
     Provides *Prv;
         Prv = Owner.ProvideP;
     };
  };
- // Package file 
+                                                                       /*}}}*/
+ // Package file                                                               /*{{{*/
  class pkgCache::PkgFileIterator
  {
     pkgCache *Owner;
     // Iteration
     void operator ++(int) {if (File!= Owner->PkgFileP) File = Owner->PkgFileP + File->NextFile;};
     inline void operator ++() {operator ++(0);};
 -   inline bool end() const {return File == Owner->PkgFileP?true:false;};
 +   inline bool end() const {return Owner == 0 || File == Owner->PkgFileP?true:false;};
  
     // Comparison
     inline bool operator ==(const PkgFileIterator &B) const {return File == B.File;};
     inline PkgFileIterator(pkgCache &Owner) : Owner(&Owner), File(Owner.PkgFileP) {};
     inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Owner(&Owner), File(Trg) {};
  };
- // Version File 
+                                                                       /*}}}*/
+ // Version File                                                               /*{{{*/
  class pkgCache::VerFileIterator
  {
     pkgCache *Owner;
     // Iteration
     void operator ++(int) {if (FileP != Owner->VerFileP) FileP = Owner->VerFileP + FileP->NextFile;};
     inline void operator ++() {operator ++(0);};
 -   inline bool end() const {return FileP == Owner->VerFileP?true:false;};
 +   inline bool end() const {return Owner == 0 || FileP == Owner->VerFileP?true:false;};
  
     // Comparison
     inline bool operator ==(const VerFileIterator &B) const {return FileP == B.FileP;};
     inline VerFileIterator() : Owner(0), FileP(0) {};
     inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Owner(&Owner), FileP(Trg) {};
  };
- // Description File 
+                                                                       /*}}}*/
+ // Description File                                                   /*{{{*/
  class pkgCache::DescFileIterator
  {
     pkgCache *Owner;
     // Iteration
     void operator ++(int) {if (FileP != Owner->DescFileP) FileP = Owner->DescFileP + FileP->NextFile;};
     inline void operator ++() {operator ++(0);};
 -   inline bool end() const {return FileP == Owner->DescFileP?true:false;};
 +   inline bool end() const {return Owner == 0 ||  FileP == Owner->DescFileP?true:false;};
  
     // Comparison
     inline bool operator ==(const DescFileIterator &B) const {return FileP == B.FileP;};
     inline DescFileIterator() : Owner(0), FileP(0) {};
     inline DescFileIterator(pkgCache &Owner,DescFile *Trg) : Owner(&Owner), FileP(Trg) {};
  };
- // Inlined Begin functions cant be in the class because of order problems
+                                                                       /*}}}*/
+ // Inlined Begin functions cant be in the class because of order problems /*{{{*/
  inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
         {return VerIterator(*Owner,Owner->VerP + Pkg->VersionList);};
  inline pkgCache::VerIterator pkgCache::PkgIterator::CurrentVer() const
@@@ -442,5 -442,5 +442,5 @@@ inline pkgCache::VerFileIterator pkgCac
         {return VerFileIterator(*Owner,Owner->VerFileP + Ver->FileList);};
  inline pkgCache::DescFileIterator pkgCache::DescIterator::FileList() const
         {return DescFileIterator(*Owner,Owner->DescFileP + Desc->FileList);};
+                                                                       /*}}}*/
  #endif
diff --combined apt-pkg/cdrom.cc
index a31602dfac1b9049735234c861ded2f64be51917,891c59836b411dca16c44579f99e4b1297336153..8796805bbab301af77679a7c31aeaf5c7b021c04
@@@ -160,7 -160,7 +160,7 @@@ bool pkgCdrom::FindPackages(string CD
     
     return !_error->PendingError();
  }
+                                                                       /*}}}*/
  // Score - We compute a 'score' for a path                            /*{{{*/
  // ---------------------------------------------------------------------
  /* Paths are scored based on how close they come to what I consider
@@@ -210,7 -210,6 +210,6 @@@ int pkgCdrom::Score(string Path
  
     return Res;
  }
                                                                        /*}}}*/
  // DropBinaryArch - Dump dirs with a string like /binary-<foo>/               /*{{{*/
  // ---------------------------------------------------------------------
@@@ -248,8 -247,7 +247,7 @@@ bool pkgCdrom::DropBinaryArch(vector<st
     
     return true;
  }
+                                                                       /*}}}*/
  // DropRepeats - Drop repeated files resulting from symlinks          /*{{{*/
  // ---------------------------------------------------------------------
  /* Here we go and stat every file that we found and strip dup inodes. */
@@@ -304,7 -302,6 +302,6 @@@ bool pkgCdrom::DropRepeats(vector<strin
     return true;
  }
                                                                        /*}}}*/
  // ReduceSourceList - Takes the path list and reduces it              /*{{{*/
  // ---------------------------------------------------------------------
  /* This takes the list of source list expressed entires and collects
@@@ -513,9 -510,8 +510,8 @@@ bool pkgCdrom::WriteSourceList(string N
     
     return true;
  }
- bool pkgCdrom::Ident(string &ident, pkgCdromStatus *log)
+                                                                       /*}}}*/
+ bool pkgCdrom::Ident(string &ident, pkgCdromStatus *log)              /*{{{*/
  {
     stringstream msg;
  
  
     return true;
  }
- bool pkgCdrom::Add(pkgCdromStatus *log)
+                                                                       /*}}}*/
+ bool pkgCdrom::Add(pkgCdromStatus *log)                                       /*{{{*/
  {
     stringstream msg;
  
     {
        if (_config->FindB("APT::CDROM::NoMount",false) == false) 
         UnmountCdrom(CDROM);
 -      return _error->Error("Unable to locate any package files, perhaps this is not a Debian Disc");
 +      return _error->Error(_("Unable to locate any package files, perhaps this is not a Debian Disc or the wrong architecture?"));
     }
  
     // Check if the CD is in the database
  
     return true;
  }
+                                                                       /*}}}*/
index 70f2db06d8eff462f4ad32758abc01fb17b76f85,52b9bfbe6c78e18ce24d02119a56a610d93b21a2..b43771ea7aea338075eb13707be9568434cea309
@@@ -34,7 -34,7 +34,7 @@@ HashString::HashString(string Type, str
  {
  }
  
- HashString::HashString(string StringedHash)
+ HashString::HashString(string StringedHash)                           /*{{{*/
  {
     // legacy: md5sum without "MD5Sum:" prefix
     if (StringedHash.find(":") == string::npos && StringedHash.size() == 32)
@@@ -50,9 -50,8 +50,8 @@@
     if(_config->FindB("Debug::Hashes",false) == true)
        std::clog << "HashString(string): " << Type << " : " << Hash << std::endl;
  }
- bool HashString::VerifyFile(string filename) const
+                                                                       /*}}}*/
+ bool HashString::VerifyFile(string filename) const                    /*{{{*/
  {
     FileFd fd;
     MD5Summation MD5;
@@@ -83,7 -82,7 +82,7 @@@
  
     return (fileHash == Hash);
  }
+                                                                       /*}}}*/
  const char** HashString::SupportedHashes()
  {
     return _SupportedHashes;
@@@ -94,13 -93,11 +93,11 @@@ bool HashString::empty() cons
     return (Type.empty() || Hash.empty());
  }
  
  string HashString::toStr() const
  {
     return Type+string(":")+Hash;
  }
  
  // Hashes::AddFD - Add the contents of the FD                         /*{{{*/
  // ---------------------------------------------------------------------
  /* */
@@@ -108,16 -105,11 +105,16 @@@ bool Hashes::AddFD(int Fd,unsigned lon
  {
     unsigned char Buf[64*64];
     int Res = 0;
 -   while (Size != 0)
 +   int ToEOF = (Size == 0);
 +   while (Size != 0 || ToEOF)
     {
 -      Res = read(Fd,Buf,min(Size,(unsigned long)sizeof(Buf)));
 -      if (Res < 0 || (unsigned)Res != min(Size,(unsigned long)sizeof(Buf)))
 -       return false;
 +      unsigned n = sizeof(Buf);
 +      if (!ToEOF) n = min(Size,(unsigned long)n);
 +      Res = read(Fd,Buf,n);
 +      if (Res < 0 || (!ToEOF && (unsigned) Res != n)) // error, or short read
 +         return false;
 +      if (ToEOF && Res == 0) // EOF
 +         break;
        Size -= Res;
        MD5.Add(Buf,Res);
        SHA1.Add(Buf,Res);
diff --combined apt-pkg/contrib/mmap.cc
index 04a45811b63351a5fe00d4d7cd1466fcc88e65de,ba4482131d4c1fd7b5ddc4388d3b16c9b93ed0a1..229b18037c149ef2353ec2d5e4476e5f5704e0d7
     libc6 generates warnings -- which should be errors, g++ isn't properly
     strict.
     
-    The configure test notes that some OS's have broken private mmap's
-    so on those OS's we can't use mmap. This means we have to use
-    configure to test mmap and can't rely on the POSIX
-    _POSIX_MAPPED_FILES test.
-    
     ##################################################################### */
                                                                        /*}}}*/
  // Include Files                                                      /*{{{*/
@@@ -31,6 -26,7 +26,7 @@@
  #include <sys/stat.h>
  #include <unistd.h>
  #include <fcntl.h>
+ #include <stdlib.h>
  
  #include <cstring>
                                                                        /*}}}*/
@@@ -141,10 -137,11 +137,11 @@@ bool MMap::Sync(unsigned long Start,uns
  }
                                                                        /*}}}*/
  
+                                                                       /*}}}*/
  // DynamicMMap::DynamicMMap - Constructor                             /*{{{*/
  // ---------------------------------------------------------------------
  /* */
- DynamicMMap::DynamicMMap(FileFd &F,unsigned long Flags,unsigned long WorkSpace) : 
+ DynamicMMap::DynamicMMap(FileFd &F,unsigned long Flags,unsigned long WorkSpace) :
               MMap(F,Flags | NoImmMap), Fd(&F), WorkSpace(WorkSpace)
  {
     if (_error->PendingError() == true)
                                                                        /*}}}*/
  // DynamicMMap::DynamicMMap - Constructor for a non-file backed map   /*{{{*/
  // ---------------------------------------------------------------------
- /* This is just a fancy malloc really.. */
+ /* We try here to use mmap to reserve some space - this is much more
+    cooler than the fallback solution to simply allocate a char array
+    and could come in handy later than we are able to grow such an mmap */
  DynamicMMap::DynamicMMap(unsigned long Flags,unsigned long WorkSpace) :
               MMap(Flags | NoImmMap | UnMapped), Fd(0), WorkSpace(WorkSpace)
  {
     if (_error->PendingError() == true)
        return;
-    
+ #ifdef _POSIX_MAPPED_FILES
+    // use anonymous mmap() to get the memory
+    Base = (unsigned char*) mmap(0, WorkSpace, PROT_READ|PROT_WRITE,
 -                      MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
 -   if(Base != MAP_FAILED)
++                                MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
++   if(Base == MAP_FAILED)
+       return;
 -#endif
++#else
+    // fallback to a static allocated space
     Base = new unsigned char[WorkSpace];
     memset(Base,0,WorkSpace);
++#endif
     iSize = 0;
  }
                                                                        /*}}}*/
@@@ -185,7 -192,11 +193,11 @@@ DynamicMMap::~DynamicMMap(
  {
     if (Fd == 0)
     {
 -      munmap(Base, WorkSpace);
+ #ifdef _POSIX_MAPPED_FILES
++      if(munmap(Base, WorkSpace) < 0)
+ #else
        delete [] (unsigned char *)Base;
+ #endif
        return;
     }
     
@@@ -204,17 -215,19 +216,19 @@@ unsigned long DynamicMMap::RawAllocate(
     unsigned long Result = iSize;
     if (Aln != 0)
        Result += Aln - (iSize%Aln);
-    
     iSize = Result + Size;
-    
-    // Just in case error check
-    if (Result + Size > WorkSpace)
+    // try to grow the buffer
+    while(Result + Size > WorkSpace)
     {
-         _error->Error(_("Dynamic MMap ran out of room. Please increase the size "
-                                 "of APT::Cache-Limit. Current value: %lu. (man 5 apt.conf)"), WorkSpace);
-       return 0;
+       if(!Grow())
+       {
+        _error->Error(_("Dynamic MMap ran out of room. Please increase the size "
+                        "of APT::Cache-Limit. Current value: %lu. (man 5 apt.conf)"), WorkSpace);
+        return 0;
+       }
     }
     return Result;
  }
                                                                        /*}}}*/
  /* This allocates an Item of size ItemSize so that it is aligned to its
     size in the file. */
  unsigned long DynamicMMap::Allocate(unsigned long ItemSize)
- {   
+ {
     // Look for a matching pool entry
     Pool *I;
     Pool *Empty = 0;
        if (I->ItemSize == ItemSize)
         break;
     }
     // No pool is allocated, use an unallocated one
     if (I == Pools + PoolCount)
     {
        I->ItemSize = ItemSize;
        I->Count = 0;
     }
-    
+    unsigned long Result = 0;
     // Out of space, allocate some more
     if (I->Count == 0)
     {
-       I->Count = 20*1024/ItemSize;
-       I->Start = RawAllocate(I->Count*ItemSize,ItemSize);
-    }   
+       const unsigned long size = 20*1024;
+       I->Count = size/ItemSize;
+       Result = RawAllocate(size,ItemSize);
+       // Does the allocation failed ?
+       if (Result == 0 && _error->PendingError())
+        return 0;
+       I->Start = Result;
+    }
+    else
+       Result = I->Start;
  
     I->Count--;
-    unsigned long Result = I->Start;
-    I->Start += ItemSize;  
+    I->Start += ItemSize;
     return Result/ItemSize;
  }
                                                                        /*}}}*/
  unsigned long DynamicMMap::WriteString(const char *String,
                                       unsigned long Len)
  {
-    unsigned long Result = iSize;
-    // Just in case error check
-    if (Result + Len > WorkSpace)
-    {
-         _error->Error(_("Dynamic MMap ran out of room. Please increase the size "
-                                 "of APT::Cache-Limit. Current value: %lu. (man 5 apt.conf)"), WorkSpace);
-       return 0;
-    }   
-    
     if (Len == (unsigned long)-1)
        Len = strlen(String);
-    iSize += Len + 1;
+    unsigned long Result = RawAllocate(Len+1,0);
+    if (Result == 0 && _error->PendingError())
+       return 0;
     memcpy((char *)Base + Result,String,Len);
     ((char *)Base)[Result + Len] = 0;
     return Result;
  }
                                                                        /*}}}*/
+ // DynamicMMap::Grow - Grow the mmap                                  /*{{{*/
+ // ---------------------------------------------------------------------
+ /* This method will try to grow the mmap we currently use. This doesn't
+    work most of the time because we can't move the mmap around in the
+    memory for now as this would require to adjust quite a lot of pointers
+    but why we should not at least try to grow it before we give up? */
+ bool DynamicMMap::Grow()
+ {
+ #ifdef _POSIX_MAPPED_FILES
+    unsigned long newSize = WorkSpace + 1024*1024;
+    if(Fd != 0)
+    {
+       Fd->Seek(newSize - 1);
+       char C = 0;
+       Fd->Write(&C,sizeof(C));
+    }
+    Base = mremap(Base, WorkSpace, newSize, 0);
+    if(Base == MAP_FAILED)
+       return false;
+    WorkSpace = newSize;
+    return true;
+ #else
+    return false;
+ #endif
+ }
+                                                                       /*}}}*/
diff --combined apt-pkg/indexcopy.cc
index 5a92c79b78ef79563ec7bb05d9967999d4db5c4e,22ee29697c88b9ded3a41c9eb5ec90116b1fc58c..15696585a513544adf04030d172527e2a197429a
@@@ -522,15 -522,6 +522,15 @@@ bool SigVerify::Verify(string prefix, s
  {
     const indexRecords::checkSum *Record = MetaIndex->Lookup(file);
  
 +   // we skip non-existing files in the verifcation to support a cdrom
 +   // with no Packages file (just a Package.gz), see LP: #255545
 +   // (non-existing files are not considered a error)
 +   if(!FileExists(prefix+file))
 +   {
 +      _error->Warning("Skipping non-exisiting file %s", string(prefix+file).c_str());
 +      return true;
 +   }
 +
     if (!Record) 
     {
        _error->Warning("Can't find authentication record for: %s",file.c_str());
  
     return true;
  }
- bool SigVerify::CopyMetaIndex(string CDROM, string CDName, 
+                                                                       /*}}}*/
+ bool SigVerify::CopyMetaIndex(string CDROM, string CDName,            /*{{{*/
                              string prefix, string file)
  {
        char S[400];
     
        return true;
  }
- bool SigVerify::CopyAndVerify(string CDROM,string Name,vector<string> &SigList,
+                                                                       /*}}}*/
+ bool SigVerify::CopyAndVerify(string CDROM,string Name,vector<string> &SigList,       /*{{{*/
                              vector<string> PkgList,vector<string> SrcList)
  {
     if (SigList.size() == 0)
         if(!Verify(prefix,*I, MetaIndex)) {
            // something went wrong, don't copy the Release.gpg
            // FIXME: delete any existing gpg file?
 +          _error->Discard();
            continue;    
         }
        }
  
     return true;
  }
- bool TranslationsCopy::CopyTranslations(string CDROM,string Name,vector<string> &List,
-                            pkgCdromStatus *log)
+                                                                       /*}}}*/
+ bool TranslationsCopy::CopyTranslations(string CDROM,string Name,     /*{{{*/
+                               vector<string> &List, pkgCdromStatus *log)
  {
     OpProgress *Progress = NULL;
     if (List.size() == 0)
  
     return true;
  }
+                                                                       /*}}}*/
diff --combined apt-pkg/indexrecords.cc
index ab208e246ebf6afe92c6747681d916e3c58579a1,77fe03d45b051c61bfcaca41bb546d78d2ceac00..1fc27b1a148b80215027a1658e665a0c376a1c29
@@@ -9,7 -9,7 +9,7 @@@
  #include <apt-pkg/strutl.h>
  #include <apti18n.h>
  #include <sys/stat.h>
+                                                                       /*}}}*/
  string indexRecords::GetDist() const
  {
     return this->Dist;
@@@ -31,20 -31,20 +31,20 @@@ const indexRecords::checkSum *indexReco
     return Entries[MetaKey];
  }
  
- bool indexRecords::Load(const string Filename)
+ bool indexRecords::Load(const string Filename)                                /*{{{*/
  {
     FileFd Fd(Filename, FileFd::ReadOnly);
     pkgTagFile TagFile(&Fd, Fd.Size() + 256); // XXX
     if (_error->PendingError() == true)
     {
 -      ErrorText = _(("Unable to parse Release file " + Filename).c_str());
 +      strprintf(ErrorText, _("Unable to parse Release file %s"),Filename.c_str());
        return false;
     }
  
     pkgTagSection Section;
     if (TagFile.Step(Section) == false)
     {
 -      ErrorText = _(("No sections in Release file " + Filename).c_str());
 +      strprintf(ErrorText, _("No sections in Release file %s"), Filename.c_str());
        return false;
     }
  
  
     if(HashString::SupportedHashes()[i] == NULL)
     {
 -      ErrorText = _(("No Hash entry in Release file " + Filename).c_str());
 +      strprintf(ErrorText, _("No Hash entry in Release file %s"), Filename.c_str());
        return false;
     }  
  
     string Strdate = Section.FindS("Date"); // FIXME: verify this somehow?
     return true;
  }
- vector<string> indexRecords::MetaKeys()
+                                                                       /*}}}*/
+ vector<string> indexRecords::MetaKeys()                                       /*{{{*/
  {
     std::vector<std::string> keys;
     std::map<string,checkSum *>::iterator I = Entries.begin();
@@@ -96,8 -96,8 +96,8 @@@
     }
     return keys;
  }
- bool indexRecords::parseSumData(const char *&Start, const char *End,
+                                                                       /*}}}*/
+ bool indexRecords::parseSumData(const char *&Start, const char *End,  /*{{{*/
                                   string &Name, string &Hash, size_t &Size)
  {
     Name = "";
     Start = EntryEnd; //prepare for the next round
     return true;
  }
+                                                                       /*}}}*/
  indexRecords::indexRecords()
  {
  }
diff --combined cmdline/apt-cache.cc
index c30e22b7691242d697344a579577ec6e9a3f2b96,57da9426f6f12b41ef0814655d0a4a7165afb82b..0e950310be80214cc0b5f40392e2884604b4d149
@@@ -102,13 -102,15 +102,13 @@@ bool UnMet(CommandLine &CmdL
            if (End->Type != pkgCache::Dep::PreDepends &&
                End->Type != pkgCache::Dep::Depends && 
                End->Type != pkgCache::Dep::Suggests &&
 -              End->Type != pkgCache::Dep::Recommends &&
 -              End->Type != pkgCache::Dep::DpkgBreaks)
 +              End->Type != pkgCache::Dep::Recommends)
               continue;
  
            // Important deps only
            if (Important == true)
               if (End->Type != pkgCache::Dep::PreDepends &&
 -                 End->Type != pkgCache::Dep::Depends &&
 -                 End->Type != pkgCache::Dep::DpkgBreaks)
 +                 End->Type != pkgCache::Dep::Depends)
                  continue;
            
            // Verify the or group
@@@ -555,7 -557,6 +555,7 @@@ bool Depends(CommandLine &CmdL
     
     bool Recurse = _config->FindB("APT::Cache::RecurseDepends",false);
     bool Installed = _config->FindB("APT::Cache::Installed",false);
 +   bool Important = _config->FindB("APT::Cache::Important",false);
     bool DidSomething;
     do
     {
         
         for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; D++)
         {
 -
 +          // Important deps only
 +          if (Important == true)
 +             if (D->Type != pkgCache::Dep::PreDepends &&
 +                 D->Type != pkgCache::Dep::Depends)
 +                continue;
 +                
            pkgCache::PkgIterator Trg = D.TargetPkg();
  
            if((Installed && Trg->CurrentVer != 0) || !Installed)
     
     return true;
  }
+                                                                       /*}}}*/
  // RDepends - Print out a reverse dependency tree - mbc                       /*{{{*/
  // ---------------------------------------------------------------------
  /* */
@@@ -714,10 -710,7 +714,7 @@@ bool RDepends(CommandLine &CmdL
     
     return true;
  }
                                                                        /*}}}*/
  // xvcg - Generate a graph for xvcg                                   /*{{{*/
  // ---------------------------------------------------------------------
  // Code contributed from Junichi Uekawa <dancer@debian.org> on 20 June 2002.
@@@ -937,8 -930,6 +934,6 @@@ bool XVcg(CommandLine &CmdL
     return true;
  }
                                                                        /*}}}*/
  // Dotty - Generate a graph for Dotty                                 /*{{{*/
  // ---------------------------------------------------------------------
  /* Dotty is the graphvis program for generating graphs. It is a fairly
@@@ -1274,15 -1265,16 +1269,16 @@@ bool DisplayRecord(pkgCache::VerIterato
     return true;
  }
                                                                        /*}}}*/
- // Search - Perform a search                                          /*{{{*/
- // ---------------------------------------------------------------------
- /* This searches the package names and package descriptions for a pattern */
  struct ExDescFile
  {
     pkgCache::DescFile *Df;
     bool NameMatch;
  };
  
+ // Search - Perform a search                                          /*{{{*/
+ // ---------------------------------------------------------------------
+ /* This searches the package names and package descriptions for a pattern */
  bool Search(CommandLine &CmdL)
  {
     pkgCache &Cache = *GCache;
@@@ -1533,8 -1525,7 +1529,8 @@@ bool Policy(CommandLine &CmdL
         if (SrcList->FindIndex(F,Indx) == false &&
             _system->FindIndex(F,Indx) == false)
            return _error->Error(_("Cache is out of sync, can't x-ref a package file"));
 -       printf(_("%4i %s\n"),
 +       
 +       printf("%4i %s\n",
                Plcy.GetPriority(F),Indx->Describe(true).c_str());
         
         // Print the reference information for the package
@@@ -1696,7 -1687,6 +1692,6 @@@ bool Madison(CommandLine &CmdL
  
     return true;
  }
                                                                        /*}}}*/
  // GenCaches - Call the main cache generator                          /*{{{*/
  // ---------------------------------------------------------------------
@@@ -1770,8 -1760,7 +1765,7 @@@ void CacheInitialize(
     _config->Set("help",false);
  }
                                                                        /*}}}*/
- int main(int argc,const char *argv[])
+ int main(int argc,const char *argv[])                                 /*{{{*/
  {
     CommandLine::Args Args[] = {
        {'h',"help","help",0},
            
     return 0;
  }
+                                                                       /*}}}*/
diff --combined debian/changelog
index 6e03bbbd43f1f8f0ff503eb3069f4283d52ad805,ea7e0469bdf514d16f24c1d1e05da992f729ce1a..970c7029fc4d279e1609df133a938877f395c178
@@@ -1,11 -1,9 +1,13 @@@
  apt (0.7.22) UNRELEASED; urgency=low
  
++  The 'not dead yet' release
++  
    [ Christian Perrier ]
    * Documentation translations:
      - Fix a typo in apt-get(8) French translation. Closes: #525043
        Thanks to Guillaume Delacour for spotting it.
 +    - Updated apt.conf(5) manpgae French translation.
 +      Thanks to AurĂ©lien Couderc.
    * Translations:
      - fr.po
      - sk.po. Closes: #525857 
    * add Debug::pkgProblemResolver::ShowScores and make the scores
      adjustable
    * do not write state file in simulate mode (closes: #433007)
-   * add hook for auto-install (closes: #470035)
-   * support IsAutoInstallOk in the resolver too
+   * add hook for MarkInstall and MarkDelete (closes: #470035)
    * fix typo in apt-pkg/acquire.cc which prevents Dl-Limit to work
      correctly when downloading from multiple sites (Closes: #534752)
+   * add the various foldmarkers in apt-pkg & cmdline (no code change)
+   * versions with a pin of -1 shouldn't be a candidate (Closes: #355237)
+   * prefer mmap as memory allocator in MMap instead of a static char
+     array which can (at least in theory) grow dynamic
+   * eliminate (hopefully all) segfaults in pkgcachegen.cc and mmap.cc
+     which can arise if cache doesn't fit into the mmap (Closes: #535218)
+   * display warnings instead of errors if the parts dirs doesn't exist
  
    [ Michael Vogt ]
-   * honor the dpkg hold state in AutoInstOk (closes: #64141)
+   * honor the dpkg hold state in new Marker hooks (closes: #64141)
    * debian/apt.cron.daily:
      - if the timestamp is too far in the future, delete it
 -
 +  * apt-pkg/acquire.cc:
 +    - make the max pipeline depth of the acquire queue configurable
 +      via Acquire::Max-Pipeline-Depth
 +  * apt-pkg/deb/dpkgpm.cc:
 +    - add Dpkg::UseIoNice boolean option to run dpkg with ionice -c3
 +      (off by default)
 +    - send "dpkg-exec" message on the status fd when dpkg is run
 +    - provide DPkg::Chroot-Directory config option (useful for testing)
 +    - fix potential hang when in a backgroud process group
 +  * apt-pkg/algorithms.cc:
 +    - consider recommends when making the scores for the problem 
 +      resolver
 +  * apt-pkg/acquire-worker.cc:
 +    - show error details of failed methods
 +  * apt-pkg/contrib/fileutl.cc:
 +    - if a process aborts with signal, show signal number
 +  * methods/http.cc:
 +    - ignore SIGPIPE, we deal with EPIPE from write in 
 +      HttpMethod::ServerDie() (LP: #385144)
 +  * apt-pkg/indexcopy.cc:
 +    - support having CDs with no Packages file (just a Packages.gz)
 +      by not forcing a verification on non-existing files
 +     (LP: #255545)
 +    - remove the gettext from a string that consists entirely 
 +      of variables (LP: #56792)
 +  * apt-pkg/cacheiterators.h:
 +    - add missing checks for Owner == 0 in end()
 +  * apt-pkg/indexrecords.cc:
 +    - fix some i18n issues
 +  * apt-pkg/contrib/strutl.h:
 +    - add new strprintf() function to make i18n strings easier
 +    - fix compiler warning
 +  * apt-pkg/deb/debsystem.cc:
 +    - make strings i18n able 
 +  * fix problematic use of tolower() when calculating the version 
 +    hash by using locale independant tolower_ascii() function. 
 +    Thanks to M. Vefa Bicakci (LP: #80248)
 +  * build fixes for g++-4.4
 +  * cmdline/apt-mark:
 +    - add "showauto" option to show automatically installed packages
 +  * document --install-recommends and --no-install-recommends
 +    (thanks to Dereck Wonnacott, LP: #126180)
 +  
    [ Julian Andres Klode ]
    * apt-pkg/contrib/configuration.cc: Fix a small memory leak in
      ReadConfigFile.
    * configure-index: document Dir::Etc::SourceParts and some other options
      (Closes: #459605)
    * Remove Eugene V. Lyubimkin from uploaders as requested.
 +  * apt-pkg/contrib/hashes.cc, apt-pkg/contrib/md5.cc:
 +    - Support reading until EOF if Size=0 to match behaviour of
 +      SHA1Summation and SHA256Summation
 +
 +  [ Osamu Aoki ]
 +  * Updated cron script to support backups by hardlinks and 
 +    verbose levels.  All features turned off by default. 
 +  * Added more error handlings.  Closes: #438803, #462734, #454989, 
 +  * Refactored condition structure to make download and upgrade performed 
 +    if only previous steps succeeded. Closes: #341970
 +  * Documented all cron script related configuration items in 
 +    configure-index.
 +
 +  [ Dereck Wonnacott ]
 +  * apt-ftparchive might write corrupt Release files (LP: #46439)
 +  * Apply --important option to apt-cache depends (LP: #16947) 
  
   -- Julian Andres Klode <jak@debian.org>  Fri, 03 Jul 2009 08:27:35 +0200
  
  apt (0.7.21) unstable; urgency=low
diff --combined doc/apt-get.8.xml
index 609674d751af756306aa7925662a3bf9b588bb1d,50971d0f55110d5cdfd0191097fdbc0555ad8556..920f6b36eddb8889b72c0ae6990ecc7ebfbf68a9
       Configuration Item: <literal>APT::Get::Simulate</literal>.</para>
  
       <para>Simulation run as user will deactivate locking (<literal>Debug::NoLocking</literal>)
-      automatical and display a notice indicating that this is only a simulation.
+      automatical. Also a notice will be displayed indicating that this is only a simulation,
+      if the option <literal>APT::Get::Show-User-Simulation-Note</literal> is set (Default: true)
       Neigther NoLocking nor the notice will be triggered if run as root (root should know what
       he is doing without further warnings by <literal>apt-get</literal>).</para>
  
       Configuration Item: <literal>APT::Get::Compile</literal>.</para></listitem>
       </varlistentry>
  
 +     <varlistentry><term><option>--install-recommends</option></term>
 +     <listitem><para>Also install recommended packages.</para></listitem>
 +     </varlistentry>
 +
 +     <varlistentry><term><option>--no-install-recommends</option></term>
 +     <listitem><para>Do not install recommended packages.</para></listitem>
 +     </varlistentry>
 +
       <varlistentry><term><option>--ignore-hold</option></term>
       <listitem><para>Ignore package Holds; This causes <command>apt-get</command> to ignore a hold 
       placed on a package. This may be useful in conjunction with 
index ada6b12cec49ba3e5855f295fafbb177981514ce,2045ca1f3d5701773af7d934bed2177008cd4f78..5dc7b5246f49927a2ac191660a0161e71e1703e8
@@@ -55,6 -55,7 +55,7 @@@ AP
       Diff-Only "false";
       Tar-Only "false";
       Build-Dep-Automatic "true";
+      Show-User-Simulation-Note "true";
    };
  
    Cache 
    // Keep the list of FDs open (normally apt closes all fds when it
    // does a ExecFork)
    Keep-Fds {};
 +
 +  // control parameters for cron jobs by /etc/cron.daily/apt
 +  Periodic
 +  {
 +  BackupArchiveInterval "0";
 +  // - Backup after n-days if archive contents changed.(0=disable)
 +
 +  BackupLevel "3";
 +  // - Backup level.(0=disable), 1 is invalid.
 +
 +  // APT::Archives::MaxAge "0"; (old, deprecated)
 +  MaxAge "0"; // (new)
 +  // - Set maximum allowed age of a cache package file. If a cache 
 +  //   package file is older it is deleted (0=disable)
 +
 +  // APT::Archives::MinAge "2"; (old, deprecated)
 +  MinAge "2"; // (new)
 +  // - Set minimum age of a package file. If a file is younger it
 +  //   will not be deleted (0=disable). Usefull to prevent races 
 +  //   and to keep backups of the packages for emergency.
 +
 +  // APT::Archives::MaxSize "0"; (old, deprecated)
 +  MaxSize "0"; // (new)
 +  // - Set maximum size of the cache in MB (0=disable). If the cache
 +  //   is bigger, cached package files are deleted until the size
 +  //   requirement is met (the biggest packages will be deleted 
 +  //   first).
 +
 +  Update-Package-Lists "0";
 +  // - Do "apt-get update" automatically every n-days (0=disable)
 +  //   
 +  Download-Upgradeable-Packages "0";
 +  // - Do "apt-get upgrade --download-only" every n-days (0=disable)
 +  //
 +  Unattended-Upgrade "0";
 +  // - Run the "unattended-upgrade" security upgrade script 
 +  //   every n-days (0=disabled)
 +  //   Requires the package "unattended-upgrades" and will write
 +  //   a log in /var/log/unattended-upgrades
 +  //
 +  AutocleanInterval "0";
 +  // - Do "apt-get autoclean" every n-days (0=disable)
 +
 +  Verbose "0";
 +  // - Send report mail to root
 +  //   0:  no report             (or null string)
 +  //   1:  progress report       (actually any string)
 +  //   2:  + command outputs     (remove -qq, remove 2>/dev/null, add -d)
 +  //   3:  + trace on            
 +  };
  };
  
  // Options for the downloading routines
@@@ -263,8 -214,6 +264,8 @@@ Dir "/
    // Location of the cache dir
    Cache "var/cache/apt/" {
       Archives "archives/";
 +     // backup directory created by /etc/cron.daily/apt
 +     Backup "backup/"; 
       srcpkgcache "srcpkgcache.bin";
       pkgcache "pkgcache.bin";     
    };