]> git.saurik.com Git - apt.git/blobdiff - cmdline/apt-get.cc
projects / apt.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
add a simple unit test for acquire progress
[apt.git] / cmdline / apt-get.cc
diff --git a/cmdline/apt-get.cc b/cmdline/apt-get.cc
index 392eafe4fff01290433a161831394e6917b315ce..1a4f4c5a847d94791146ba09e2c9f36a7aefecae 100644 (file)
--- a/cmdline/apt-get.cc
+++ b/cmdline/apt-get.cc
@@ -15,7 +15,7 @@
       upgrade - Smart-Download the newest versions of all packages
       dselect-upgrade - Follows dselect's changes to the Status: field
                        and installes new and removes old packages
       upgrade - Smart-Download the newest versions of all packages
       dselect-upgrade - Follows dselect's changes to the Status: field
                        and installes new and removes old packages
-      dist-upgrade - Powerfull upgrader designed to handle the issues with
+      dist-upgrade - Powerful upgrader designed to handle the issues with
                     a new distribution.
       install - Download and install a given package (by name, not by .deb)
       check - Update the package cache and check for broken packages
                     a new distribution.
       install - Download and install a given package (by name, not by .deb)
       check - Update the package cache and check for broken packages
@@ -27,73 +27,79 @@
 // Include Files                                                       /*{{{*/
 #include <config.h>
 
 // Include Files                                                       /*{{{*/
 #include <config.h>
 
+#include <apt-pkg/acquire-item.h>
+#include <apt-pkg/algorithms.h>
 #include <apt-pkg/aptconfiguration.h>
 #include <apt-pkg/aptconfiguration.h>
-#include <apt-pkg/error.h>
+#include <apt-pkg/cachefile.h>
+#include <apt-pkg/cacheset.h>
+#include <apt-pkg/clean.h>
 #include <apt-pkg/cmndline.h>
 #include <apt-pkg/cmndline.h>
-#include <apt-pkg/init.h>
+#include <apt-pkg/debmetaindex.h>
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/depcache.h>
-#include <apt-pkg/sourcelist.h>
-#include <apt-pkg/algorithms.h>
-#include <apt-pkg/acquire-item.h>
-#include <apt-pkg/strutl.h>
+#include <apt-pkg/error.h>
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/fileutl.h>
-#include <apt-pkg/clean.h>
-#include <apt-pkg/srcrecords.h>
-#include <apt-pkg/version.h>
-#include <apt-pkg/cachefile.h>
-#include <apt-pkg/cacheset.h>
-#include <apt-pkg/sptr.h>
+#include <apt-pkg/indexfile.h>
+#include <apt-pkg/indexrecords.h>
+#include <apt-pkg/init.h>
 #include <apt-pkg/md5.h>
 #include <apt-pkg/md5.h>
-#include <apt-pkg/versionmatch.h>
-#include <apt-pkg/progress.h>
-#include <apt-pkg/pkgsystem.h>
+#include <apt-pkg/metaindex.h>
 #include <apt-pkg/pkgrecords.h>
 #include <apt-pkg/pkgrecords.h>
-#include <apt-pkg/indexfile.h>
-
+#include <apt-pkg/pkgsystem.h>
+#include <apt-pkg/progress.h>
+#include <apt-pkg/sourcelist.h>
+#include <apt-pkg/srcrecords.h>
+#include <apt-pkg/strutl.h>
+#include <apt-pkg/version.h>
+#include <apt-pkg/acquire.h>
+#include <apt-pkg/configuration.h>
+#include <apt-pkg/macros.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/cacheiterators.h>
+#include <apt-pkg/upgrade.h>
 
 
-#include <apt-private/private-install.h>
-#include <apt-private/private-upgrade.h>
-#include <apt-private/private-output.h>
+#include <apt-private/acqprogress.h>
 #include <apt-private/private-cacheset.h>
 #include <apt-private/private-cacheset.h>
-#include <apt-private/private-update.h>
+#include <apt-private/private-cachefile.h>
 #include <apt-private/private-cmndline.h>
 #include <apt-private/private-cmndline.h>
+#include <apt-private/private-download.h>
+#include <apt-private/private-install.h>
+#include <apt-private/private-main.h>
 #include <apt-private/private-moo.h>
 #include <apt-private/private-moo.h>
+#include <apt-private/private-output.h>
+#include <apt-private/private-update.h>
+#include <apt-private/private-upgrade.h>
+#include <apt-private/private-utils.h>
 
 
-#include <apt-private/acqprogress.h>
-
-#include <set>
-#include <locale.h>
-#include <langinfo.h>
-#include <fstream>
-#include <termios.h>
-#include <sys/ioctl.h>
-#include <sys/stat.h>
-#include <sys/statfs.h>
-#include <sys/statvfs.h>
+#include <errno.h>
 #include <signal.h>
 #include <signal.h>
-#include <unistd.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <stdio.h>
-#include <errno.h>
-#include <regex.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
 #include <sys/wait.h>
 #include <sys/wait.h>
-#include <sstream>
+#include <unistd.h>
+#include <pwd.h>
+#include <grp.h>
 
 
-#include <apt-private/private-output.h>
-#include <apt-private/private-main.h>
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <set>
+#include <string>
+#include <vector>
 
 #include <apti18n.h>
                                                                        /*}}}*/
 
 
 #include <apti18n.h>
                                                                        /*}}}*/
 
-
 using namespace std;
 
 using namespace std;
 
-
-
 // TryToInstallBuildDep - Try to install a single package              /*{{{*/
 // ---------------------------------------------------------------------
 /* This used to be inlined in DoInstall, but with the advent of regex package
    name matching it was split out.. */
 // TryToInstallBuildDep - Try to install a single package              /*{{{*/
 // ---------------------------------------------------------------------
 /* This used to be inlined in DoInstall, but with the advent of regex package
    name matching it was split out.. */
-bool TryToInstallBuildDep(pkgCache::PkgIterator Pkg,pkgCacheFile &Cache,
+static bool TryToInstallBuildDep(pkgCache::PkgIterator Pkg,pkgCacheFile &Cache,
                  pkgProblemResolver &Fix,bool Remove,bool BrokenFix,
                  bool AllowFail = true)
 {
                  pkgProblemResolver &Fix,bool Remove,bool BrokenFix,
                  bool AllowFail = true)
 {
@@ -130,24 +136,73 @@ bool TryToInstallBuildDep(pkgCache::PkgIterator Pkg,pkgCacheFile &Cache,
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/
+// GetReleaseForSourceRecord - Return Suite for the given srcrecord    /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+static std::string GetReleaseForSourceRecord(pkgSourceList *SrcList,
+                                      pkgSrcRecords::Parser *Parse)
+{
+   // try to find release
+   const pkgIndexFile& CurrentIndexFile = Parse->Index();
+
+   for (pkgSourceList::const_iterator S = SrcList->begin(); 
+        S != SrcList->end(); ++S)
+   {
+      vector<pkgIndexFile *> *Indexes = (*S)->GetIndexFiles();
+      for (vector<pkgIndexFile *>::const_iterator IF = Indexes->begin();
+           IF != Indexes->end(); ++IF)
+      {
+         if (&CurrentIndexFile == (*IF))
+         {
+            std::string const path = (*S)->LocalFileName();
+            if (path != "")
+            {
+               indexRecords records;
+               records.Load(path);
+               return records.GetSuite();
+            }
+         }
+      }
+   }
+   return "";
+}
+                                                                       /*}}}*/
 // FindSrc - Find a source record                                      /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // FindSrc - Find a source record                                      /*{{{*/
 // ---------------------------------------------------------------------
 /* */
-pkgSrcRecords::Parser *FindSrc(const char *Name,pkgRecords &Recs,
+#if APT_PKG_ABI >= 413
+static pkgSrcRecords::Parser *FindSrc(const char *Name,
+#else
+static pkgSrcRecords::Parser *FindSrc(const char *Name,pkgRecords &Recs,
+#endif
                               pkgSrcRecords &SrcRecs,string &Src,
                               pkgSrcRecords &SrcRecs,string &Src,
-                              pkgDepCache &Cache)
+                              CacheFile &CacheFile)
 {
 {
-   string VerTag;
-   string DefRel = _config->Find("APT::Default-Release");
+   string VerTag, UserRequestedVerTag;
+   string ArchTag = "";
+   string RelTag = _config->Find("APT::Default-Release");
    string TmpSrc = Name;
    string TmpSrc = Name;
+   pkgDepCache *Cache = CacheFile.GetDepCache();
 
 
-   // extract the version/release from the pkgname
-   const size_t found = TmpSrc.find_last_of("/=");
-   if (found != string::npos) {
-      if (TmpSrc[found] == '/')
-        DefRel = TmpSrc.substr(found+1);
-      else
-        VerTag = TmpSrc.substr(found+1);
+   // extract release
+   size_t found = TmpSrc.find_last_of("/");
+   if (found != string::npos) 
+   {
+      RelTag = TmpSrc.substr(found+1);
+      TmpSrc = TmpSrc.substr(0,found);
+   }
+   // extract the version
+   found = TmpSrc.find_last_of("=");
+   if (found != string::npos) 
+   {
+      VerTag = UserRequestedVerTag = TmpSrc.substr(found+1);
+      TmpSrc = TmpSrc.substr(0,found);
+   }
+   // extract arch 
+   found = TmpSrc.find_last_of(":");
+   if (found != string::npos) 
+   {
+      ArchTag = TmpSrc.substr(found+1);
       TmpSrc = TmpSrc.substr(0,found);
    }
 
       TmpSrc = TmpSrc.substr(0,found);
    }
 
@@ -155,10 +210,25 @@ pkgSrcRecords::Parser *FindSrc(const char *Name,pkgRecords &Recs,
       install a version and determine the source package name, then look
       in the archive for a source package of the same name. */
    bool MatchSrcOnly = _config->FindB("APT::Get::Only-Source");
       install a version and determine the source package name, then look
       in the archive for a source package of the same name. */
    bool MatchSrcOnly = _config->FindB("APT::Get::Only-Source");
-   const pkgCache::PkgIterator Pkg = Cache.FindPkg(TmpSrc);
+   pkgCache::PkgIterator Pkg;
+   if (ArchTag != "")
+      Pkg = Cache->FindPkg(TmpSrc, ArchTag);
+   else
+      Pkg = Cache->FindPkg(TmpSrc);
+
+   // if we can't find a package but the user qualified with a arch,
+   // error out here
+   if (Pkg.end() && ArchTag != "")
+   {
+      Src = Name;
+      _error->Error(_("Can not find a package for architecture '%s'"),
+                    ArchTag.c_str());
+      return 0;
+   }
+
    if (MatchSrcOnly == false && Pkg.end() == false) 
    {
    if (MatchSrcOnly == false && Pkg.end() == false) 
    {
-      if(VerTag.empty() == false || DefRel.empty() == false) 
+      if(VerTag != "" || RelTag != "" || ArchTag != "")
       {
         bool fuzzy = false;
         // we have a default release, try to locate the pkg. we do it like
       {
         bool fuzzy = false;
         // we have a default release, try to locate the pkg. we do it like
@@ -178,9 +248,20 @@ pkgSrcRecords::Parser *FindSrc(const char *Name,pkgRecords &Recs,
               if (Ver.end() == true)
                  break;
            }
               if (Ver.end() == true)
                  break;
            }
+
+            // ignore arches that are not for us
+            if (ArchTag != "" && Ver.Arch() != ArchTag)
+               continue;
+
+            // pick highest version for the arch unless the user wants
+            // something else
+            if (ArchTag != "" && VerTag == "" && RelTag == "")
+               if(Cache->VS().CmpVersion(VerTag, Ver.VerStr()) < 0)
+                  VerTag = Ver.VerStr();
+
            // We match against a concrete version (or a part of this version)
            if (VerTag.empty() == false &&
            // We match against a concrete version (or a part of this version)
            if (VerTag.empty() == false &&
-               (fuzzy == true || Cache.VS().CmpVersion(VerTag, Ver.VerStr()) != 0) && // exact match
+               (fuzzy == true || Cache->VS().CmpVersion(VerTag, Ver.VerStr()) != 0) && // exact match
                (fuzzy == false || strncmp(VerTag.c_str(), Ver.VerStr(), VerTag.size()) != 0)) // fuzzy match
               continue;
 
                (fuzzy == false || strncmp(VerTag.c_str(), Ver.VerStr(), VerTag.size()) != 0)) // fuzzy match
               continue;
 
@@ -198,53 +279,73 @@ pkgSrcRecords::Parser *FindSrc(const char *Name,pkgRecords &Recs,
 
               // or we match against a release
               if(VerTag.empty() == false ||
 
               // or we match against a release
               if(VerTag.empty() == false ||
-                 (VF.File().Archive() != 0 && VF.File().Archive() == DefRel) ||
-                 (VF.File().Codename() != 0 && VF.File().Codename() == DefRel)) 
+                 (VF.File().Archive() != 0 && VF.File().Archive() == RelTag) ||
+                 (VF.File().Codename() != 0 && VF.File().Codename() == RelTag)) 
               {
               {
+                 // the Version we have is possibly fuzzy or includes binUploads,
+                 // so we use the Version of the SourcePkg (empty if same as package)
+#if APT_PKG_ABI >= 413
+                 Src = Ver.SourcePkgName();
+                 VerTag = Ver.SourceVerStr();
+#else
                  pkgRecords::Parser &Parse = Recs.Lookup(VF);
                  Src = Parse.SourcePkg();
                  // no SourcePkg name, so it is the "binary" name
                  if (Src.empty() == true)
                     Src = TmpSrc;
                  pkgRecords::Parser &Parse = Recs.Lookup(VF);
                  Src = Parse.SourcePkg();
                  // no SourcePkg name, so it is the "binary" name
                  if (Src.empty() == true)
                     Src = TmpSrc;
-                 // the Version we have is possibly fuzzy or includes binUploads,
-                 // so we use the Version of the SourcePkg (empty if same as package)
                  VerTag = Parse.SourceVer();
                  if (VerTag.empty() == true)
                     VerTag = Ver.VerStr();
                  VerTag = Parse.SourceVer();
                  if (VerTag.empty() == true)
                     VerTag = Ver.VerStr();
+#endif
                  break;
               }
            }
            if (Src.empty() == false)
               break;
         }
                  break;
               }
            }
            if (Src.empty() == false)
               break;
         }
-        if (Src.empty() == true) 
-        {
-           // Sources files have no codename information
-           if (VerTag.empty() == true && DefRel.empty() == false) 
-           {
-              _error->Error(_("Ignore unavailable target release '%s' of package '%s'"), DefRel.c_str(), TmpSrc.c_str());
-              return 0;
-           }
-        }
       }
       }
+
+      if (Src == "" && ArchTag != "")
+      {
+         if (VerTag != "")
+            _error->Error(_("Can not find a package '%s' with version '%s'"),
+                          Pkg.FullName().c_str(), VerTag.c_str());
+         if (RelTag != "")
+            _error->Error(_("Can not find a package '%s' with release '%s'"),
+                          Pkg.FullName().c_str(), RelTag.c_str());
+         Src = Name;
+         return 0;
+      }
+
+
       if (Src.empty() == true)
       {
         // if we don't have found a fitting package yet so we will
         // choose a good candidate and proceed with that.
         // Maybe we will find a source later on with the right VerTag
       if (Src.empty() == true)
       {
         // if we don't have found a fitting package yet so we will
         // choose a good candidate and proceed with that.
         // Maybe we will find a source later on with the right VerTag
-        pkgCache::VerIterator Ver = Cache.GetCandidateVer(Pkg);
+         // or RelTag
+        pkgCache::VerIterator Ver = Cache->GetCandidateVer(Pkg);
         if (Ver.end() == false) 
         {
         if (Ver.end() == false) 
         {
+#if APT_PKG_ABI >= 413
+           if (strcmp(Ver.SourcePkgName(),Ver.ParentPkg().Name()) != 0)
+              Src = Ver.SourcePkgName();
+           if (VerTag.empty() == true && strcmp(Ver.SourceVerStr(),Ver.VerStr()) != 0)
+              VerTag = Ver.SourceVerStr();
+#else
            pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
            Src = Parse.SourcePkg();
            if (VerTag.empty() == true)
               VerTag = Parse.SourceVer();
            pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
            Src = Parse.SourcePkg();
            if (VerTag.empty() == true)
               VerTag = Parse.SourceVer();
+#endif
         }
       }
    }
 
    if (Src.empty() == true)
         }
       }
    }
 
    if (Src.empty() == true)
+   {
       Src = TmpSrc;
       Src = TmpSrc;
+   }
    else 
    {
       /* if we have a source pkg name, make sure to only search
    else 
    {
       /* if we have a source pkg name, make sure to only search
@@ -262,6 +363,7 @@ pkgSrcRecords::Parser *FindSrc(const char *Name,pkgRecords &Recs,
    pkgSrcRecords::Parser *Last = 0;
    unsigned long Offset = 0;
    string Version;
    pkgSrcRecords::Parser *Last = 0;
    unsigned long Offset = 0;
    string Version;
+   pkgSourceList *SrcList = CacheFile.GetSourceList();
 
    /* Iterate over all of the hits, which includes the resulting
       binary packages in the search */
 
    /* Iterate over all of the hits, which includes the resulting
       binary packages in the search */
@@ -273,26 +375,43 @@ pkgSrcRecords::Parser *FindSrc(const char *Name,pkgRecords &Recs,
       {
         const string Ver = Parse->Version();
 
       {
         const string Ver = Parse->Version();
 
+         // See if we need to look for a specific release tag
+         if (RelTag != "" && UserRequestedVerTag == "")
+         {
+            const string Rel = GetReleaseForSourceRecord(SrcList, Parse);
+
+            if (Rel == RelTag)
+            {
+               Last = Parse;
+               Offset = Parse->Offset();
+               Version = Ver;
+            }
+         }
+
         // Ignore all versions which doesn't fit
         if (VerTag.empty() == false &&
         // Ignore all versions which doesn't fit
         if (VerTag.empty() == false &&
-            Cache.VS().CmpVersion(VerTag, Ver) != 0) // exact match
+            Cache->VS().CmpVersion(VerTag, Ver) != 0) // exact match
            continue;
 
         // Newer version or an exact match? Save the hit
            continue;
 
         // Newer version or an exact match? Save the hit
-        if (Last == 0 || Cache.VS().CmpVersion(Version,Ver) < 0) {
+        if (Last == 0 || Cache->VS().CmpVersion(Version,Ver) < 0) {
            Last = Parse;
            Offset = Parse->Offset();
            Version = Ver;
         }
 
            Last = Parse;
            Offset = Parse->Offset();
            Version = Ver;
         }
 
-        // was the version check above an exact match? If so, we don't need to look further
-        if (VerTag.empty() == false && VerTag.size() == Ver.size())
+        // was the version check above an exact match?
+         // If so, we don't need to look further
+         if (VerTag.empty() == false && (VerTag == Ver))
            break;
       }
            break;
       }
+      if (UserRequestedVerTag == "" && Version != "" && RelTag != "")
+         ioprintf(c1out, "Selected version '%s' (%s) for %s\n", 
+                  Version.c_str(), RelTag.c_str(), Src.c_str());
+
       if (Last != 0 || VerTag.empty() == true)
         break;
       if (Last != 0 || VerTag.empty() == true)
         break;
-      //if (VerTag.empty() == false && Last == 0)
-      _error->Error(_("Ignore unavailable version '%s' of package '%s'"), VerTag.c_str(), TmpSrc.c_str());
+      _error->Error(_("Can not find version '%s' of package '%s'"), VerTag.c_str(), TmpSrc.c_str());
       return 0;
    }
 
       return 0;
    }
 
@@ -303,7 +422,7 @@ pkgSrcRecords::Parser *FindSrc(const char *Name,pkgRecords &Recs,
 }
                                                                        /*}}}*/
 /* mark packages as automatically/manually installed.                  {{{*/
 }
                                                                        /*}}}*/
 /* mark packages as automatically/manually installed.                  {{{*/
-bool DoMarkAuto(CommandLine &CmdL)
+static bool DoMarkAuto(CommandLine &CmdL)
 {
    bool Action = true;
    int AutoMarkChanged = 0;
 {
    bool Action = true;
    int AutoMarkChanged = 0;
@@ -345,35 +464,10 @@ bool DoMarkAuto(CommandLine &CmdL)
    return false;
 }
                                                                        /*}}}*/
    return false;
 }
                                                                        /*}}}*/
-// DoDistUpgrade - Automatic smart upgrader                            /*{{{*/
-// ---------------------------------------------------------------------
-/* Intelligent upgrader that will install and remove packages at will */
-bool DoDistUpgrade(CommandLine &CmdL)
-{
-   if (CmdL.FileSize() != 1)
-      return _error->Error(_("The dist-upgrade command takes no arguments"));
-
-   CacheFile Cache;
-   if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
-      return false;
-
-   c0out << _("Calculating upgrade... ") << flush;
-   if (pkgDistUpgrade(*Cache) == false)
-   {
-      c0out << _("Failed") << endl;
-      ShowBroken(c1out,Cache,false);
-      return false;
-   }
-   
-   c0out << _("Done") << endl;
-   
-   return InstallPackages(Cache,true);
-}
-                                                                       /*}}}*/
 // DoDSelectUpgrade - Do an upgrade by following dselects selections   /*{{{*/
 // ---------------------------------------------------------------------
 /* Follows dselect's selections */
 // DoDSelectUpgrade - Do an upgrade by following dselects selections   /*{{{*/
 // ---------------------------------------------------------------------
 /* Follows dselect's selections */
-bool DoDSelectUpgrade(CommandLine &CmdL)
+static bool DoDSelectUpgrade(CommandLine &)
 {
    CacheFile Cache;
    if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
 {
    CacheFile Cache;
    if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
@@ -411,7 +505,7 @@ bool DoDSelectUpgrade(CommandLine &CmdL)
    }
 
    /* Resolve any problems that dselect created, allupgrade cannot handle
    }
 
    /* Resolve any problems that dselect created, allupgrade cannot handle
-      such things. We do so quite agressively too.. */
+      such things. We do so quite aggressively too.. */
    if (Cache->BrokenCount() != 0)
    {      
       pkgProblemResolver Fix(Cache);
    if (Cache->BrokenCount() != 0)
    {      
       pkgProblemResolver Fix(Cache);
@@ -437,7 +531,7 @@ bool DoDSelectUpgrade(CommandLine &CmdL)
    }
 
    // Now upgrade everything
    }
 
    // Now upgrade everything
-   if (pkgAllUpgrade(Cache) == false)
+   if (APT::Upgrade::Upgrade(Cache, APT::Upgrade::FORBID_REMOVE_PACKAGES | APT::Upgrade::FORBID_INSTALL_NEW_PACKAGES) == false)
    {
       ShowBroken(c1out,Cache,false);
       return _error->Error(_("Internal error, problem resolver broke stuff"));
    {
       ShowBroken(c1out,Cache,false);
       return _error->Error(_("Internal error, problem resolver broke stuff"));
@@ -449,33 +543,29 @@ bool DoDSelectUpgrade(CommandLine &CmdL)
 // DoClean - Remove download archives                                  /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // DoClean - Remove download archives                                  /*{{{*/
 // ---------------------------------------------------------------------
 /* */
-bool DoClean(CommandLine &CmdL)
+static bool DoClean(CommandLine &)
 {
    std::string const archivedir = _config->FindDir("Dir::Cache::archives");
 {
    std::string const archivedir = _config->FindDir("Dir::Cache::archives");
-   std::string const pkgcache = _config->FindFile("Dir::cache::pkgcache");
-   std::string const srcpkgcache = _config->FindFile("Dir::cache::srcpkgcache");
+   std::string const listsdir = _config->FindDir("Dir::state::lists");
 
    if (_config->FindB("APT::Get::Simulate") == true)
    {
 
    if (_config->FindB("APT::Get::Simulate") == true)
    {
+      std::string const pkgcache = _config->FindFile("Dir::cache::pkgcache");
+      std::string const srcpkgcache = _config->FindFile("Dir::cache::srcpkgcache");
       cout << "Del " << archivedir << "* " << archivedir << "partial/*"<< endl
       cout << "Del " << archivedir << "* " << archivedir << "partial/*"<< endl
+          << "Del " << listsdir << "partial/*" << endl
           << "Del " << pkgcache << " " << srcpkgcache << endl;
       return true;
    }
           << "Del " << pkgcache << " " << srcpkgcache << endl;
       return true;
    }
-   
-   // Lock the archive directory
-   FileFd Lock;
-   if (_config->FindB("Debug::NoLocking",false) == false)
-   {
-      int lock_fd = GetLock(archivedir + "lock");
-      if (lock_fd < 0)
-        return _error->Error(_("Unable to lock the download directory"));
-      Lock.Fd(lock_fd);
-   }
-   
+
    pkgAcquire Fetcher;
    pkgAcquire Fetcher;
+   Fetcher.GetLock(archivedir);
    Fetcher.Clean(archivedir);
    Fetcher.Clean(archivedir + "partial/");
 
    Fetcher.Clean(archivedir);
    Fetcher.Clean(archivedir + "partial/");
 
+   Fetcher.GetLock(listsdir);
+   Fetcher.Clean(listsdir + "partial/");
+
    pkgCacheFile::RemoveCaches();
 
    return true;
    pkgCacheFile::RemoveCaches();
 
    return true;
@@ -497,7 +587,7 @@ class LogCleaner : public pkgArchiveCleaner
    };
 };
 
    };
 };
 
-bool DoAutoClean(CommandLine &CmdL)
+static bool DoAutoClean(CommandLine &)
 {
    // Lock the archive directory
    FileFd Lock;
 {
    // Lock the archive directory
    FileFd Lock;
@@ -521,87 +611,83 @@ bool DoAutoClean(CommandLine &CmdL)
                                                                        /*}}}*/
 // DoDownload - download a binary                                      /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // DoDownload - download a binary                                      /*{{{*/
 // ---------------------------------------------------------------------
-bool DoDownload(CommandLine &CmdL)
+static bool DoDownload(CommandLine &CmdL)
 {
    CacheFile Cache;
    if (Cache.ReadOnlyOpen() == false)
       return false;
 {
    CacheFile Cache;
    if (Cache.ReadOnlyOpen() == false)
       return false;
-   
+
    APT::CacheSetHelper helper(c0out);
    APT::CacheSetHelper helper(c0out);
-   APT::VersionList verset = APT::VersionList::FromCommandLine(Cache,
-               CmdL.FileList + 1, APT::VersionList::CANDIDATE, helper);
+   APT::VersionSet verset = APT::VersionSet::FromCommandLine(Cache,
+               CmdL.FileList + 1, APT::CacheSetHelper::CANDIDATE, helper);
 
    if (verset.empty() == true)
       return false;
 
 
    if (verset.empty() == true)
       return false;
 
-   pkgAcquire Fetcher;
-   AcqTextStatus Stat(ScreenWidth, _config->FindI("quiet",0));
-   if (_config->FindB("APT::Get::Print-URIs") == false)
-      Fetcher.Setup(&Stat);
+   AcqTextStatus Stat(std::cout, ScreenWidth,_config->FindI("quiet",0));
+   pkgAcquire Fetcher(&Stat);
 
    pkgRecords Recs(Cache);
    pkgSourceList *SrcList = Cache.GetSourceList();
 
    pkgRecords Recs(Cache);
    pkgSourceList *SrcList = Cache.GetSourceList();
-   bool gotAll = true;
 
 
-   for (APT::VersionList::const_iterator Ver = verset.begin(); 
-        Ver != verset.end(); 
-        ++Ver) 
+   // reuse the usual acquire methods for deb files, but don't drop them into
+   // the usual directories - keep everything in the current directory
+   std::vector<std::string> storefile(verset.size());
+   std::string const cwd = SafeGetCWD();
+   _config->Set("Dir::Cache::Archives", cwd);
+   int i = 0;
+   for (APT::VersionSet::const_iterator Ver = verset.begin();
+        Ver != verset.end(); ++Ver, ++i)
    {
    {
-      string descr;
-      // get the right version
-      pkgCache::PkgIterator Pkg = Ver.ParentPkg();
-      pkgRecords::Parser &rec=Recs.Lookup(Ver.FileList());
-      pkgCache::VerFileIterator Vf = Ver.FileList();
-      if (Vf.end() == true)
-      {
-        _error->Error("Can not find VerFile for %s in version %s", Pkg.FullName().c_str(), Ver.VerStr());
-        gotAll = false;
+      pkgAcquire::Item *I = new pkgAcqArchive(&Fetcher, SrcList, &Recs, *Ver, storefile[i]);
+      if (storefile[i].empty())
         continue;
         continue;
-      }
-      pkgCache::PkgFileIterator F = Vf.File();
-      pkgIndexFile *index;
-      if(SrcList->FindIndex(F, index) == false)
-      {
-        _error->Error(_("Can't find a source to download version '%s' of '%s'"), Ver.VerStr(), Pkg.FullName().c_str());
-        gotAll = false;
-        continue;
-      }
-      string uri = index->ArchiveURI(rec.FileName());
-      strprintf(descr, _("Downloading %s %s"), Pkg.Name(), Ver.VerStr());
-      // get the most appropriate hash
-      HashString hash;
-      if (rec.SHA512Hash() != "")
-         hash = HashString("sha512", rec.SHA512Hash());
-      else if (rec.SHA256Hash() != "")
-         hash = HashString("sha256", rec.SHA256Hash());
-      else if (rec.SHA1Hash() != "")
-         hash = HashString("sha1", rec.SHA1Hash());
-      else if (rec.MD5Hash() != "")
-         hash = HashString("md5", rec.MD5Hash());
-      // get the file
-      new pkgAcqFile(&Fetcher, uri, hash.toStr(), (*Ver)->Size, descr, Pkg.Name(), ".");
+      std::string const filename = cwd + flNotDir(storefile[i]);
+      storefile[i].assign(filename);
+      I->DestFile.assign(filename);
    }
    }
-   if (gotAll == false)
-      return false;
 
    // Just print out the uris and exit if the --print-uris flag was used
    if (_config->FindB("APT::Get::Print-URIs") == true)
    {
       pkgAcquire::UriIterator I = Fetcher.UriBegin();
       for (; I != Fetcher.UriEnd(); ++I)
 
    // Just print out the uris and exit if the --print-uris flag was used
    if (_config->FindB("APT::Get::Print-URIs") == true)
    {
       pkgAcquire::UriIterator I = Fetcher.UriBegin();
       for (; I != Fetcher.UriEnd(); ++I)
-        cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' << 
+        cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile)  << ' ' <<
               I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
       return true;
    }
 
               I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
       return true;
    }
 
-   return (Fetcher.Run() == pkgAcquire::Continue);
+   // Disable drop-privs if "_apt" can not write to the target dir
+   CheckDropPrivsMustBeDisabled(Fetcher);
+
+   if (_error->PendingError() == true || CheckAuth(Fetcher, false) == false)
+      return false;
+
+   bool Failed = false;
+   if (AcquireRun(Fetcher, 0, &Failed, NULL) == false)
+      return false;
+
+   // copy files in local sources to the current directory
+   for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); ++I)
+   {
+      std::string const filename = cwd + flNotDir((*I)->DestFile);
+      if ((*I)->Local == true &&
+          filename != (*I)->DestFile &&
+          (*I)->Status == pkgAcquire::Item::StatDone)
+      {
+        std::ifstream src((*I)->DestFile.c_str(), std::ios::binary);
+        std::ofstream dst(filename.c_str(), std::ios::binary);
+        dst << src.rdbuf();
+      }
+   }
+   return Failed == false;
 }
                                                                        /*}}}*/
 // DoCheck - Perform the check operation                               /*{{{*/
 // ---------------------------------------------------------------------
 /* Opening automatically checks the system, this command is mostly used
    for debugging */
 }
                                                                        /*}}}*/
 // DoCheck - Perform the check operation                               /*{{{*/
 // ---------------------------------------------------------------------
 /* Opening automatically checks the system, this command is mostly used
    for debugging */
-bool DoCheck(CommandLine &CmdL)
+static bool DoCheck(CommandLine &)
 {
    CacheFile Cache;
    Cache.Open();
 {
    CacheFile Cache;
    Cache.Open();
@@ -620,7 +706,7 @@ struct DscFile
    string Dsc;
 };
 
    string Dsc;
 };
 
-bool DoSource(CommandLine &CmdL)
+static bool DoSource(CommandLine &CmdL)
 {
    CacheFile Cache;
    if (Cache.Open(false) == false)
 {
    CacheFile Cache;
    if (Cache.Open(false) == false)
@@ -635,17 +721,18 @@ bool DoSource(CommandLine &CmdL)
    pkgSourceList *List = Cache.GetSourceList();
    
    // Create the text record parsers
    pkgSourceList *List = Cache.GetSourceList();
    
    // Create the text record parsers
+#if APT_PKG_ABI < 413
    pkgRecords Recs(Cache);
    pkgRecords Recs(Cache);
+#endif
    pkgSrcRecords SrcRecs(*List);
    if (_error->PendingError() == true)
       return false;
 
    // Create the download object
    pkgSrcRecords SrcRecs(*List);
    if (_error->PendingError() == true)
       return false;
 
    // Create the download object
-   AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));   
-   pkgAcquire Fetcher;
-   Fetcher.SetLog(&Stat);
+   AcqTextStatus Stat(std::cout, ScreenWidth,_config->FindI("quiet",0));
+   pkgAcquire Fetcher(&Stat);
 
 
-   DscFile *Dsc = new DscFile[CmdL.FileSize()];
+   SPtrArray<DscFile> Dsc = new DscFile[CmdL.FileSize()];
    
    // insert all downloaded uris into this set to avoid downloading them
    // twice
    
    // insert all downloaded uris into this set to avoid downloading them
    // twice
@@ -660,15 +747,21 @@ bool DoSource(CommandLine &CmdL)
 
    // Load the requestd sources into the fetcher
    unsigned J = 0;
 
    // Load the requestd sources into the fetcher
    unsigned J = 0;
+   std::string UntrustedList;
    for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
    {
       string Src;
    for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
    {
       string Src;
-      pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,*Cache);
-      
+#if APT_PKG_ABI >= 413
+      pkgSrcRecords::Parser *Last = FindSrc(*I,SrcRecs,Src,Cache);
+#else
+      pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,Cache);
+#endif
       if (Last == 0) {
       if (Last == 0) {
-        delete[] Dsc;
         return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
       }
         return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
       }
+
+      if (Last->Index().IsTrusted() == false)
+         UntrustedList += Src + " ";
       
       string srec = Last->AsStr();
       string::size_type pos = srec.find("\nVcs-");
       
       string srec = Last->AsStr();
       string::size_type pos = srec.find("\nVcs-");
@@ -698,14 +791,13 @@ bool DoSource(CommandLine &CmdL)
       }
 
       // Back track
       }
 
       // Back track
-      vector<pkgSrcRecords::File> Lst;
-      if (Last->Files(Lst) == false) {
-        delete[] Dsc;
+      vector<pkgSrcRecords::File2> Lst;
+      if (Last->Files2(Lst) == false) {
         return false;
       }
 
       // Load them into the fetcher
         return false;
       }
 
       // Load them into the fetcher
-      for (vector<pkgSrcRecords::File>::const_iterator I = Lst.begin();
+      for (vector<pkgSrcRecords::File2>::const_iterator I = Lst.begin();
           I != Lst.end(); ++I)
       {
         // Try to guess what sort of file it is we are getting.
           I != Lst.end(); ++I)
       {
         // Try to guess what sort of file it is we are getting.
@@ -734,56 +826,36 @@ bool DoSource(CommandLine &CmdL)
         queued.insert(Last->Index().ArchiveURI(I->Path));
 
         // check if we have a file with that md5 sum already localy
         queued.insert(Last->Index().ArchiveURI(I->Path));
 
         // check if we have a file with that md5 sum already localy
-        if(!I->MD5Hash.empty() && FileExists(flNotDir(I->Path)))  
-        {
-           FileFd Fd(flNotDir(I->Path), FileFd::ReadOnly);
-           MD5Summation sum;
-           sum.AddFD(Fd.Fd(), Fd.Size());
-           Fd.Close();
-           if((string)sum.Result() == I->MD5Hash) 
+        std::string localFile = flNotDir(I->Path);
+        if (FileExists(localFile) == true)
+           if(I->Hashes.VerifyFile(localFile) == true)
            {
               ioprintf(c1out,_("Skipping already downloaded file '%s'\n"),
            {
               ioprintf(c1out,_("Skipping already downloaded file '%s'\n"),
-                       flNotDir(I->Path).c_str());
+                       localFile.c_str());
               continue;
            }
               continue;
            }
+
+        // see if we have a hash (Acquire::ForceHash is the only way to have none)
+        if (I->Hashes.usable() == false && _config->FindB("APT::Get::AllowUnauthenticated",false) == false)
+        {
+           ioprintf(c1out, "Skipping download of file '%s' as requested hashsum is not available for authentication\n",
+                    localFile.c_str());
+           continue;
         }
 
         new pkgAcqFile(&Fetcher,Last->Index().ArchiveURI(I->Path),
         }
 
         new pkgAcqFile(&Fetcher,Last->Index().ArchiveURI(I->Path),
-                       I->MD5Hash,I->Size,
-                       Last->Index().SourceInfo(*Last,*I),Src);
+                       I->Hashes, I->FileSize, Last->Index().SourceInfo(*Last,*I), Src);
       }
    }
       }
    }
-   
+
    // Display statistics
    unsigned long long FetchBytes = Fetcher.FetchNeeded();
    unsigned long long FetchPBytes = Fetcher.PartialPresent();
    unsigned long long DebBytes = Fetcher.TotalNeeded();
 
    // Display statistics
    unsigned long long FetchBytes = Fetcher.FetchNeeded();
    unsigned long long FetchPBytes = Fetcher.PartialPresent();
    unsigned long long DebBytes = Fetcher.TotalNeeded();
 
-   // Check for enough free space
-   struct statvfs Buf;
-   string OutputDir = ".";
-   if (statvfs(OutputDir.c_str(),&Buf) != 0) {
-      delete[] Dsc;
-      if (errno == EOVERFLOW)
-        return _error->WarningE("statvfs",_("Couldn't determine free space in %s"),
-                               OutputDir.c_str());
-      else
-        return _error->Errno("statvfs",_("Couldn't determine free space in %s"),
-                               OutputDir.c_str());
-   } else if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
-     {
-       struct statfs Stat;
-       if (statfs(OutputDir.c_str(),&Stat) != 0
-#if HAVE_STRUCT_STATFS_F_TYPE
-           || unsigned(Stat.f_type) != RAMFS_MAGIC
-#endif
-           )  {
-        delete[] Dsc;
-          return _error->Error(_("You don't have enough free space in %s"),
-              OutputDir.c_str());
-       }
-     }
-   
+   if (CheckFreeSpaceBeforeDownload(".", (FetchBytes - FetchPBytes)) == false)
+      return false;
+
    // Number of bytes
    if (DebBytes != FetchBytes)
       //TRANSLATOR: The required space between number and unit is already included
    // Number of bytes
    if (DebBytes != FetchBytes)
       //TRANSLATOR: The required space between number and unit is already included
@@ -800,10 +872,9 @@ bool DoSource(CommandLine &CmdL)
    {
       for (unsigned I = 0; I != J; I++)
         ioprintf(cout,_("Fetch source %s\n"),Dsc[I].Package.c_str());
    {
       for (unsigned I = 0; I != J; I++)
         ioprintf(cout,_("Fetch source %s\n"),Dsc[I].Package.c_str());
-      delete[] Dsc;
       return true;
    }
       return true;
    }
-   
+
    // Just print out the uris an exit if the --print-uris flag was used
    if (_config->FindB("APT::Get::Print-URIs") == true)
    {
    // Just print out the uris an exit if the --print-uris flag was used
    if (_config->FindB("APT::Get::Print-URIs") == true)
    {
@@ -811,39 +882,26 @@ bool DoSource(CommandLine &CmdL)
       for (; I != Fetcher.UriEnd(); ++I)
         cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' << 
               I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
       for (; I != Fetcher.UriEnd(); ++I)
         cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' << 
               I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
-      delete[] Dsc;
       return true;
    }
       return true;
    }
-   
-   // Run it
-   if (Fetcher.Run() == pkgAcquire::Failed)
-   {
-      delete[] Dsc;
+
+   // Disable drop-privs if "_apt" can not write to the target dir
+   CheckDropPrivsMustBeDisabled(Fetcher);
+
+   // check authentication status of the source as well
+   if (UntrustedList != "" && !AuthPrompt(UntrustedList, false))
       return false;
       return false;
-   }
 
 
-   // Print error messages
+   // Run it
    bool Failed = false;
    bool Failed = false;
-   for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); ++I)
+   if (AcquireRun(Fetcher, 0, &Failed, NULL) == false || Failed == true)
    {
    {
-      if ((*I)->Status == pkgAcquire::Item::StatDone &&
-         (*I)->Complete == true)
-        continue;
-      
-      fprintf(stderr,_("Failed to fetch %s  %s\n"),(*I)->DescURI().c_str(),
-             (*I)->ErrorText.c_str());
-      Failed = true;
-   }
-   if (Failed == true)
-   {
-      delete[] Dsc;
       return _error->Error(_("Failed to fetch some archives."));
    }
 
    if (_config->FindB("APT::Get::Download-only",false) == true)
    {
       c1out << _("Download complete and in download only mode") << endl;
       return _error->Error(_("Failed to fetch some archives."));
    }
 
    if (_config->FindB("APT::Get::Download-only",false) == true)
    {
       c1out << _("Download complete and in download only mode") << endl;
-      delete[] Dsc;
       return true;
    }
 
       return true;
    }
 
@@ -874,44 +932,50 @@ bool DoSource(CommandLine &CmdL)
         else
         {
            // Call dpkg-source
         else
         {
            // Call dpkg-source
-           char S[500];
-           snprintf(S,sizeof(S),"%s -x %s",
+           std::string const sourceopts = _config->Find("DPkg::Source-Options", "-x");
+           std::string S;
+           strprintf(S, "%s %s %s",
                     _config->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(),
                     _config->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(),
-                    Dsc[I].Dsc.c_str());
-           if (system(S) != 0)
+                    sourceopts.c_str(), Dsc[I].Dsc.c_str());
+           if (system(S.c_str()) != 0)
            {
            {
-              fprintf(stderr,_("Unpack command '%s' failed.\n"),S);
-              fprintf(stderr,_("Check if the 'dpkg-dev' package is installed.\n"));
+              fprintf(stderr, _("Unpack command '%s' failed.\n"), S.c_str());
+              fprintf(stderr, _("Check if the 'dpkg-dev' package is installed.\n"));
               _exit(1);
               _exit(1);
-           }       
+           }
         }
         }
-        
+
         // Try to compile it with dpkg-buildpackage
         if (_config->FindB("APT::Get::Compile",false) == true)
         {
            string buildopts = _config->Find("APT::Get::Host-Architecture");
            if (buildopts.empty() == false)
               buildopts = "-a" + buildopts + " ";
         // Try to compile it with dpkg-buildpackage
         if (_config->FindB("APT::Get::Compile",false) == true)
         {
            string buildopts = _config->Find("APT::Get::Host-Architecture");
            if (buildopts.empty() == false)
               buildopts = "-a" + buildopts + " ";
+
+           // get all active build profiles
+           std::string const profiles = APT::Configuration::getBuildProfilesString();
+           if (profiles.empty() == false)
+              buildopts.append(" -P").append(profiles).append(" ");
+
            buildopts.append(_config->Find("DPkg::Build-Options","-b -uc"));
 
            // Call dpkg-buildpackage
            buildopts.append(_config->Find("DPkg::Build-Options","-b -uc"));
 
            // Call dpkg-buildpackage
-           char S[500];
-           snprintf(S,sizeof(S),"cd %s && %s %s",
+           std::string S;
+           strprintf(S, "cd %s && %s %s",
                     Dir.c_str(),
                     _config->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(),
                     buildopts.c_str());
                     Dir.c_str(),
                     _config->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(),
                     buildopts.c_str());
-           
-           if (system(S) != 0)
+
+           if (system(S.c_str()) != 0)
            {
            {
-              fprintf(stderr,_("Build command '%s' failed.\n"),S);
+              fprintf(stderr, _("Build command '%s' failed.\n"), S.c_str());
               _exit(1);
               _exit(1);
-           }       
-        }      
+           }
+        }
       }
       }
-      
+
       _exit(0);
    }
       _exit(0);
    }
-   delete[] Dsc;
 
    // Wait for the subprocess
    int Status = 0;
 
    // Wait for the subprocess
    int Status = 0;
@@ -932,7 +996,7 @@ bool DoSource(CommandLine &CmdL)
 // ---------------------------------------------------------------------
 /* This function will look at the build depends list of the given source 
    package and install the necessary packages to make it true, or fail. */
 // ---------------------------------------------------------------------
 /* This function will look at the build depends list of the given source 
    package and install the necessary packages to make it true, or fail. */
-bool DoBuildDep(CommandLine &CmdL)
+static bool DoBuildDep(CommandLine &CmdL)
 {
    CacheFile Cache;
 
 {
    CacheFile Cache;
 
@@ -950,17 +1014,13 @@ bool DoBuildDep(CommandLine &CmdL)
    pkgSourceList *List = Cache.GetSourceList();
    
    // Create the text record parsers
    pkgSourceList *List = Cache.GetSourceList();
    
    // Create the text record parsers
+#if APT_PKG_ABI < 413
    pkgRecords Recs(Cache);
    pkgRecords Recs(Cache);
+#endif
    pkgSrcRecords SrcRecs(*List);
    if (_error->PendingError() == true)
       return false;
 
    pkgSrcRecords SrcRecs(*List);
    if (_error->PendingError() == true)
       return false;
 
-   // Create the download object
-   AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));   
-   pkgAcquire Fetcher;
-   if (Fetcher.Setup(&Stat) == false)
-      return false;
-
    bool StripMultiArch;
    string hostArch = _config->Find("APT::Get::Host-Architecture");
    if (hostArch.empty() == false)
    bool StripMultiArch;
    string hostArch = _config->Find("APT::Get::Host-Architecture");
    if (hostArch.empty() == false)
@@ -977,7 +1037,39 @@ bool DoBuildDep(CommandLine &CmdL)
    for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
    {
       string Src;
    for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
    {
       string Src;
-      pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,*Cache);
+      pkgSrcRecords::Parser *Last = 0;
+
+      // an unpacked debian source tree
+      using APT::String::Startswith;
+      if ((Startswith(*I, "./") || Startswith(*I, "/")) &&
+          DirectoryExists(*I))
+      {
+         ioprintf(c1out, _("Note, using directory '%s' to get the build dependencies\n"), *I);
+         // FIXME: how can we make this more elegant?
+         std::string TypeName = "debian/control File Source Index";
+         pkgIndexFile::Type *Type = pkgIndexFile::Type::GetType(TypeName.c_str());
+         if(Type != NULL)
+            Last = Type->CreateSrcPkgParser(*I);
+      }
+      // if its a local file (e.g. .dsc) use this
+      else if (FileExists(*I))
+      {
+         ioprintf(c1out, _("Note, using file '%s' to get the build dependencies\n"), *I);
+
+         // see if we can get a parser for this pkgIndexFile type
+         string TypeName = flExtension(*I) + " File Source Index";
+         pkgIndexFile::Type *Type = pkgIndexFile::Type::GetType(TypeName.c_str());
+         if(Type != NULL)
+            Last = Type->CreateSrcPkgParser(*I);
+      } else {
+         // normal case, search the cache for the source file
+#if APT_PKG_ABI >= 413
+        Last = FindSrc(*I,SrcRecs,Src,Cache);
+#else
+        Last = FindSrc(*I,Recs,SrcRecs,Src,Cache);
+#endif
+      }
+
       if (Last == 0)
         return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
             
       if (Last == 0)
         return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
             
@@ -995,7 +1087,7 @@ bool DoBuildDep(CommandLine &CmdL)
       }
       else if (Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only", false), StripMultiArch) == false)
            return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());
       }
       else if (Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only", false), StripMultiArch) == false)
            return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());
-   
+
       // Also ensure that build-essential packages are present
       Configuration::Item const *Opts = _config->Tree("APT::Build-Essential");
       if (Opts) 
       // Also ensure that build-essential packages are present
       Configuration::Item const *Opts = _config->Tree("APT::Build-Essential");
       if (Opts) 
@@ -1326,21 +1418,24 @@ bool DoBuildDep(CommandLine &CmdL)
  * pool/ next to the deb itself)
  * Example return: "pool/main/a/apt/apt_0.8.8ubuntu3" 
  */
  * pool/ next to the deb itself)
  * Example return: "pool/main/a/apt/apt_0.8.8ubuntu3" 
  */
-string GetChangelogPath(CacheFile &Cache, 
-                        pkgCache::PkgIterator Pkg,
+static string GetChangelogPath(CacheFile &Cache,
                         pkgCache::VerIterator Ver)
 {
                         pkgCache::VerIterator Ver)
 {
-   string path;
-
    pkgRecords Recs(Cache);
    pkgRecords::Parser &rec=Recs.Lookup(Ver.FileList());
    pkgRecords Recs(Cache);
    pkgRecords::Parser &rec=Recs.Lookup(Ver.FileList());
-   string srcpkg = rec.SourcePkg().empty() ? Pkg.Name() : rec.SourcePkg();
+   string path = flNotFile(rec.FileName());
+#if APT_PKG_ABI >= 413
+   path.append(Ver.SourcePkgName());
+   path.append("_");
+   path.append(StripEpoch(Ver.SourceVerStr()));
+#else
+   string srcpkg = rec.SourcePkg().empty() ? Ver.ParentPkg().Name() : rec.SourcePkg();
    string ver = Ver.VerStr();
    // if there is a source version it always wins
    if (rec.SourceVer() != "")
       ver = rec.SourceVer();
    string ver = Ver.VerStr();
    // if there is a source version it always wins
    if (rec.SourceVer() != "")
       ver = rec.SourceVer();
-   path = flNotFile(rec.FileName());
    path += srcpkg + "_" + StripEpoch(ver);
    path += srcpkg + "_" + StripEpoch(ver);
+#endif
    return path;
 }
                                                                        /*}}}*/
    return path;
 }
                                                                        /*}}}*/
@@ -1353,8 +1448,7 @@ string GetChangelogPath(CacheFile &Cache,
  * apt-get changelog mplayer-doc:
  *  http://packages.medibuntu.org/pool/non-free/m/mplayer/mplayer_1.0~rc4~try1.dsfg1-1ubuntu1+medibuntu1.changelog
  */
  * apt-get changelog mplayer-doc:
  *  http://packages.medibuntu.org/pool/non-free/m/mplayer/mplayer_1.0~rc4~try1.dsfg1-1ubuntu1+medibuntu1.changelog
  */
-bool GuessThirdPartyChangelogUri(CacheFile &Cache, 
-                                 pkgCache::PkgIterator Pkg,
+static bool GuessThirdPartyChangelogUri(CacheFile &Cache, 
                                  pkgCache::VerIterator Ver,
                                  string &out_uri)
 {
                                  pkgCache::VerIterator Ver,
                                  string &out_uri)
 {
@@ -1369,7 +1463,7 @@ bool GuessThirdPartyChangelogUri(CacheFile &Cache,
       return false;
 
    // get archive uri for the binary deb
       return false;
 
    // get archive uri for the binary deb
-   string path_without_dot_changelog = GetChangelogPath(Cache, Pkg, Ver);
+   string path_without_dot_changelog = GetChangelogPath(Cache, Ver);
    out_uri = index->ArchiveURI(path_without_dot_changelog + ".changelog");
 
    // now strip away the filename and add srcpkg_srcver.changelog
    out_uri = index->ArchiveURI(path_without_dot_changelog + ".changelog");
 
    // now strip away the filename and add srcpkg_srcver.changelog
@@ -1378,7 +1472,7 @@ bool GuessThirdPartyChangelogUri(CacheFile &Cache,
                                                                        /*}}}*/
 // DownloadChangelog - Download the changelog                          /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // DownloadChangelog - Download the changelog                          /*{{{*/
 // ---------------------------------------------------------------------
-bool DownloadChangelog(CacheFile &CacheFile, pkgAcquire &Fetcher, 
+static bool DownloadChangelog(CacheFile &CacheFile, pkgAcquire &Fetcher, 
                        pkgCache::VerIterator Ver, string targetfile)
 /* Download a changelog file for the given package version to
  * targetfile. This will first try the server from Apt::Changelogs::Server
                        pkgCache::VerIterator Ver, string targetfile)
 /* Download a changelog file for the given package version to
  * targetfile. This will first try the server from Apt::Changelogs::Server
@@ -1387,71 +1481,54 @@ bool DownloadChangelog(CacheFile &CacheFile, pkgAcquire &Fetcher,
  * GuessThirdPartyChangelogUri for details how)
  */
 {
  * GuessThirdPartyChangelogUri for details how)
  */
 {
-   string path;
-   string descr;
-   string server;
-   string changelog_uri;
-
-   // data structures we need
-   pkgCache::PkgIterator Pkg = Ver.ParentPkg();
-
    // make the server root configurable
    // make the server root configurable
-   server = _config->Find("Apt::Changelogs::Server",
+   string const server = _config->Find("Apt::Changelogs::Server",
                           "http://packages.debian.org/changelogs");
                           "http://packages.debian.org/changelogs");
-   path = GetChangelogPath(CacheFile, Pkg, Ver);
-   strprintf(changelog_uri, "%s/%s/changelog", server.c_str(), path.c_str());
+   string const path = GetChangelogPath(CacheFile, Ver);
+   string changelog_uri;
+   if (APT::String::Endswith(server, "/") == true)
+      strprintf(changelog_uri, "%s%s/changelog", server.c_str(), path.c_str());
+   else
+      strprintf(changelog_uri, "%s/%s/changelog", server.c_str(), path.c_str());
    if (_config->FindB("APT::Get::Print-URIs", false) == true)
    {
       std::cout << '\'' << changelog_uri << '\'' << std::endl;
       return true;
    }
    if (_config->FindB("APT::Get::Print-URIs", false) == true)
    {
       std::cout << '\'' << changelog_uri << '\'' << std::endl;
       return true;
    }
+   pkgCache::PkgIterator const Pkg = Ver.ParentPkg();
 
 
+   string descr;
    strprintf(descr, _("Changelog for %s (%s)"), Pkg.Name(), changelog_uri.c_str());
    // queue it
    strprintf(descr, _("Changelog for %s (%s)"), Pkg.Name(), changelog_uri.c_str());
    // queue it
-   new pkgAcqFile(&Fetcher, changelog_uri, "", 0, descr, Pkg.Name(), "ignored", targetfile);
+   pkgAcquire::Item const * itm = new pkgAcqFile(&Fetcher, changelog_uri, "", 0, descr, Pkg.Name(), "ignored", targetfile);
+
+   // Disable drop-privs if "_apt" can not write to the target dir
+   CheckDropPrivsMustBeDisabled(Fetcher);
 
    // try downloading it, if that fails, try third-party-changelogs location
    // FIXME: Fetcher.Run() is "Continue" even if I get a 404?!?
    Fetcher.Run();
 
    // try downloading it, if that fails, try third-party-changelogs location
    // FIXME: Fetcher.Run() is "Continue" even if I get a 404?!?
    Fetcher.Run();
-   if (!FileExists(targetfile))
+   if (itm->Status != pkgAcquire::Item::StatDone)
    {
       string third_party_uri;
    {
       string third_party_uri;
-      if (GuessThirdPartyChangelogUri(CacheFile, Pkg, Ver, third_party_uri))
+      if (GuessThirdPartyChangelogUri(CacheFile, Ver, third_party_uri))
       {
          strprintf(descr, _("Changelog for %s (%s)"), Pkg.Name(), third_party_uri.c_str());
       {
          strprintf(descr, _("Changelog for %s (%s)"), Pkg.Name(), third_party_uri.c_str());
-         new pkgAcqFile(&Fetcher, third_party_uri, "", 0, descr, Pkg.Name(), "ignored", targetfile);
+         itm = new pkgAcqFile(&Fetcher, third_party_uri, "", 0, descr, Pkg.Name(), "ignored", targetfile);
          Fetcher.Run();
       }
    }
 
          Fetcher.Run();
       }
    }
 
-   if (FileExists(targetfile))
+   if (itm->Status == pkgAcquire::Item::StatDone)
       return true;
 
    // error
    return _error->Error("changelog download failed");
 }
                                                                        /*}}}*/
       return true;
 
    // error
    return _error->Error("changelog download failed");
 }
                                                                        /*}}}*/
-// DisplayFileInPager - Display File with pager                                /*{{{*/
-void DisplayFileInPager(string filename)
-{
-   pid_t Process = ExecFork();
-   if (Process == 0)
-   {
-      const char *Args[3];
-      Args[0] = "/usr/bin/sensible-pager";
-      Args[1] = filename.c_str();
-      Args[2] = 0;
-      execvp(Args[0],(char **)Args);
-      exit(100);
-   }
-         
-   // Wait for the subprocess
-   ExecWait(Process, "sensible-pager", false);
-}
-                                                                       /*}}}*/
 // DoChangelog - Get changelog from the command line                   /*{{{*/
 // ---------------------------------------------------------------------
 // DoChangelog - Get changelog from the command line                   /*{{{*/
 // ---------------------------------------------------------------------
-bool DoChangelog(CommandLine &CmdL)
+static bool DoChangelog(CommandLine &CmdL)
 {
    CacheFile Cache;
    if (Cache.ReadOnlyOpen() == false)
 {
    CacheFile Cache;
    if (Cache.ReadOnlyOpen() == false)
@@ -1459,7 +1536,7 @@ bool DoChangelog(CommandLine &CmdL)
    
    APT::CacheSetHelper helper(c0out);
    APT::VersionList verset = APT::VersionList::FromCommandLine(Cache,
    
    APT::CacheSetHelper helper(c0out);
    APT::VersionList verset = APT::VersionList::FromCommandLine(Cache,
-               CmdL.FileList + 1, APT::VersionList::CANDIDATE, helper);
+               CmdL.FileList + 1, APT::CacheSetHelper::CANDIDATE, helper);
    if (verset.empty() == true)
       return false;
    pkgAcquire Fetcher;
    if (verset.empty() == true)
       return false;
    pkgAcquire Fetcher;
@@ -1473,23 +1550,34 @@ bool DoChangelog(CommandLine &CmdL)
       return Success;
    }
 
       return Success;
    }
 
-   AcqTextStatus Stat(ScreenWidth, _config->FindI("quiet",0));
-   Fetcher.Setup(&Stat);
+   AcqTextStatus Stat(std::cout, ScreenWidth,_config->FindI("quiet",0));
+   Fetcher.SetLog(&Stat);
 
    bool const downOnly = _config->FindB("APT::Get::Download-Only", false);
 
    char tmpname[100];
 
    bool const downOnly = _config->FindB("APT::Get::Download-Only", false);
 
    char tmpname[100];
-   char* tmpdir = NULL;
+   const char* tmpdir = NULL;
    if (downOnly == false)
    {
    if (downOnly == false)
    {
-      const char* const tmpDir = getenv("TMPDIR");
-      if (tmpDir != NULL && *tmpDir != '\0')
-        snprintf(tmpname, sizeof(tmpname), "%s/apt-changelog-XXXXXX", tmpDir);
-      else
-        strncpy(tmpname, "/tmp/apt-changelog-XXXXXX", sizeof(tmpname));
+      std::string systemTemp = GetTempDir();
+      snprintf(tmpname, sizeof(tmpname), "%s/apt-changelog-XXXXXX", 
+               systemTemp.c_str());
       tmpdir = mkdtemp(tmpname);
       if (tmpdir == NULL)
         return _error->Errno("mkdtemp", "mkdtemp failed");
       tmpdir = mkdtemp(tmpname);
       if (tmpdir == NULL)
         return _error->Errno("mkdtemp", "mkdtemp failed");
+
+      std::string const SandboxUser = _config->Find("APT::Sandbox::User");
+      if (getuid() == 0 && SandboxUser.empty() == false) // if we aren't root, we can't chown, so don't try it
+      {
+        struct passwd const * const pw = getpwnam(SandboxUser.c_str());
+        struct group const * const gr = getgrnam("root");
+        if (pw != NULL && gr != NULL)
+        {
+           // chown the tmp dir directory we use to the sandbox user
+           if(chown(tmpdir, pw->pw_uid, gr->gr_gid) != 0)
+              _error->WarningE("DoChangelog", "chown to %s:%s of directory %s failed", SandboxUser.c_str(), "root", tmpdir);
+        }
+      }
    }
 
    for (APT::VersionList::const_iterator Ver = verset.begin(); 
    }
 
    for (APT::VersionList::const_iterator Ver = verset.begin(); 
@@ -1498,14 +1586,14 @@ bool DoChangelog(CommandLine &CmdL)
    {
       string changelogfile;
       if (downOnly == false)
    {
       string changelogfile;
       if (downOnly == false)
-        changelogfile.append(tmpname).append("changelog");
+        changelogfile.append(tmpname).append("/changelog");
       else
         changelogfile.append(Ver.ParentPkg().Name()).append(".changelog");
       if (DownloadChangelog(Cache, Fetcher, Ver, changelogfile) && downOnly == false)
       {
          DisplayFileInPager(changelogfile);
          // cleanup temp file
       else
         changelogfile.append(Ver.ParentPkg().Name()).append(".changelog");
       if (DownloadChangelog(Cache, Fetcher, Ver, changelogfile) && downOnly == false)
       {
          DisplayFileInPager(changelogfile);
          // cleanup temp file
-         unlink(changelogfile.c_str());
+        unlink(changelogfile.c_str());
       }
    }
    // clenaup tmp dir
       }
    }
    // clenaup tmp dir
@@ -1517,15 +1605,14 @@ bool DoChangelog(CommandLine &CmdL)
 // ShowHelp - Show a help screen                                       /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // ShowHelp - Show a help screen                                       /*{{{*/
 // ---------------------------------------------------------------------
 /* */
-bool ShowHelp(CommandLine &CmdL)
+static bool ShowHelp(CommandLine &)
 {
 {
-   ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,PACKAGE_VERSION,
-           COMMON_ARCH,__DATE__,__TIME__);
-           
+   ioprintf(cout, "%s %s (%s)\n", PACKAGE, PACKAGE_VERSION, COMMON_ARCH);
+
    if (_config->FindB("version") == true)
    {
       cout << _("Supported modules:") << endl;
    if (_config->FindB("version") == true)
    {
       cout << _("Supported modules:") << endl;
-      
+
       for (unsigned I = 0; I != pkgVersioningSystem::GlobalListLen; I++)
       {
         pkgVersioningSystem *VS = pkgVersioningSystem::GlobalList[I];
       for (unsigned I = 0; I != pkgVersioningSystem::GlobalListLen; I++)
       {
         pkgVersioningSystem *VS = pkgVersioningSystem::GlobalList[I];
@@ -1534,7 +1621,7 @@ bool ShowHelp(CommandLine &CmdL)
         else
            cout << ' ';
         cout << "Ver: " << VS->Label << endl;
         else
            cout << ' ';
         cout << "Ver: " << VS->Label << endl;
-        
+
         /* Print out all the packaging systems that will work with 
            this VS */
         for (unsigned J = 0; J != pkgSystem::GlobalListLen; J++)
         /* Print out all the packaging systems that will work with 
            this VS */
         for (unsigned J = 0; J != pkgSystem::GlobalListLen; J++)
@@ -1610,29 +1697,6 @@ bool ShowHelp(CommandLine &CmdL)
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/
-// SigWinch - Window size change signal handler                                /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-void SigWinch(int)
-{
-   // Riped from GNU ls
-#ifdef TIOCGWINSZ
-   struct winsize ws;
-  
-   if (ioctl(1, TIOCGWINSZ, &ws) != -1 && ws.ws_col >= 5)
-      ScreenWidth = ws.ws_col - 1;
-#endif
-}
-                                                                       /*}}}*/
-
-bool DoUpgrade(CommandLine &CmdL)
-{
-   if (_config->FindB("APT::Get::Upgrade-Allow-New", false) == true)
-      return DoUpgradeWithAllowNewPackages(CmdL);
-   else
-      return DoUpgradeNoNewPackages(CmdL);
-}
-
 int main(int argc,const char *argv[])                                  /*{{{*/
 {
    CommandLine::Dispatch Cmds[] = {{"update",&DoUpdate},
 int main(int argc,const char *argv[])                                  /*{{{*/
 {
    CommandLine::Dispatch Cmds[] = {{"update",&DoUpdate},
@@ -1663,42 +1727,18 @@ int main(int argc,const char *argv[])                                   /*{{{*/
    textdomain(PACKAGE);
 
    // Parse the command line and initialize the package library
    textdomain(PACKAGE);
 
    // Parse the command line and initialize the package library
-   CommandLine CmdL(Args.data(),_config);
-   if (pkgInitConfig(*_config) == false ||
-       CmdL.Parse(argc,argv) == false ||
-       pkgInitSystem(*_config,_system) == false)
-   {
-      if (_config->FindB("version") == true)
-        ShowHelp(CmdL);
-        
-      _error->DumpErrors();
-      return 100;
-   }
-
-   // See if the help should be shown
-   if (_config->FindB("help") == true ||
-       _config->FindB("version") == true ||
-       CmdL.FileSize() == 0)
-   {
-      ShowHelp(CmdL);
-      return 0;
-   }
+   CommandLine CmdL;
+   ParseCommandLine(CmdL, Cmds, Args.data(), &_config, &_system, argc, argv, ShowHelp);
 
    // see if we are in simulate mode
    CheckSimulateMode(CmdL);
 
 
    // see if we are in simulate mode
    CheckSimulateMode(CmdL);
 
-   // Deal with stdout not being a tty
-   if (!isatty(STDOUT_FILENO) && _config->FindI("quiet", -1) == -1)
-      _config->Set("quiet","1");
+   // Init the signals
+   InitSignals();
 
    // Setup the output streams
    InitOutput();
 
 
    // Setup the output streams
    InitOutput();
 
-   // Setup the signals
-   signal(SIGPIPE,SIG_IGN);
-   signal(SIGWINCH,SigWinch);
-   SigWinch(0);
-
    // Match the operation
    CmdL.DispatchArg(Cmds);
 
    // Match the operation
    CmdL.DispatchArg(Cmds);
 
APT (for Cydia)