]> git.saurik.com Git - apt.git/blobdiff - apt-private/private-download.cc
Only check for valid Date if checking Valid-Until.
[apt.git] / apt-private / private-download.cc
index 37fae18e91633c9d22bd3bbff375744b9186566e..d0cbbcf50200bc814ae02d7003e0ded44f71f089 100644 (file)
@@ -3,13 +3,19 @@
 
 #include <apt-pkg/acquire.h>
 #include <apt-pkg/acquire-item.h>
+#include <apt-pkg/cacheset.h>
+#include <apt-pkg/cmndline.h>
+#include <apt-pkg/clean.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/strutl.h>
 
-#include <apt-private/private-output.h>
+#include <apt-private/private-cachefile.h>
 #include <apt-private/private-download.h>
+#include <apt-private/private-output.h>
+#include <apt-private/private-utils.h>
+#include <apt-private/acqprogress.h>
 
 #include <fstream>
 #include <string>
 #include <sys/types.h>
 #include <pwd.h>
 #include <fcntl.h>
+#ifdef HAVE_VFS_H
 #include <sys/vfs.h>
+#else
+#ifdef HAVE_PARAMS_H
+#include <sys/params.h>
+#endif
+#include <sys/mount.h>
+#endif
 #include <sys/statvfs.h>
+#include <sys/stat.h>
 #include <errno.h>
 
 #include <apti18n.h>
                                                                        /*}}}*/
 
-bool CheckDropPrivsMustBeDisabled(pkgAcquire &Fetcher)                 /*{{{*/
-{
-   // no need/possibility to drop privs
-   if(getuid() != 0)
-      return true;
-
-   // the user does not want to drop privs
-   std::string SandboxUser = _config->Find("APT::Sandbox::User");
-   if (SandboxUser.empty())
-      return true;
-
-   struct passwd const * const pw = getpwnam(SandboxUser.c_str());
-   if (pw == NULL)
-      return true;
-
-   if (seteuid(pw->pw_uid) != 0)
-      return _error->Errno("seteuid", "seteuid %u failed", pw->pw_uid);
-
-   bool res = true;
-   // check if we can write to destfile
-   for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin();
-       I != Fetcher.ItemsEnd() && res == true; ++I)
-   {
-      if ((*I)->DestFile.empty())
-        continue;
-      // we assume that an existing (partial) file means that we have sufficient rights
-      if (RealFileExists((*I)->DestFile))
-        continue;
-      int fd = open((*I)->DestFile.c_str(), O_CREAT | O_EXCL | O_RDWR, 0600);
-      if (fd < 0)
-      {
-        res = false;
-        std::string msg;
-        strprintf(msg, _("Can't drop privileges for downloading as file '%s' couldn't be accessed by user '%s'."),
-              (*I)->DestFile.c_str(), SandboxUser.c_str());
-        std::cerr << "W: " << msg << std::endl;
-        _config->Set("APT::Sandbox::User", "");
-        break;
-      }
-      unlink((*I)->DestFile.c_str());
-      close(fd);
-   }
-
-   if (seteuid(0) != 0)
-      return _error->Errno("seteuid", "seteuid %u failed", 0);
-
-   return res;
-}
-                                                                       /*}}}*/
 // CheckAuth - check if each download comes form a trusted source      /*{{{*/
 bool CheckAuth(pkgAcquire& Fetcher, bool const PromptUser)
 {
-   std::string UntrustedList;
+   std::vector<std::string> UntrustedList;
    for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I < Fetcher.ItemsEnd(); ++I)
       if (!(*I)->IsTrusted())
-          UntrustedList += std::string((*I)->ShortDesc()) + " ";
+        UntrustedList.push_back((*I)->ShortDesc());
 
-   if (UntrustedList == "")
+   if (UntrustedList.empty())
       return true;
 
    return AuthPrompt(UntrustedList, PromptUser);
 }
-
-bool AuthPrompt(std::string const &UntrustedList, bool const PromptUser)
+                                                                       /*}}}*/
+bool AuthPrompt(std::vector<std::string> const &UntrustedList, bool const PromptUser)/*{{{*/
 {
-   ShowList(c2out,_("WARNING: The following packages cannot be authenticated!"),UntrustedList,"");
+   ShowList(c2out,_("WARNING: The following packages cannot be authenticated!"), UntrustedList,
+        [](std::string const&) { return true; },
+        [](std::string const&str) { return str; },
+        [](std::string const&) { return ""; });
 
    if (_config->FindB("APT::Get::AllowUnauthenticated",false) == true)
    {
@@ -105,16 +73,17 @@ bool AuthPrompt(std::string const &UntrustedList, bool const PromptUser)
    if (_config->FindI("quiet",0) < 2
        && _config->FindB("APT::Get::Assume-Yes",false) == false)
    {
-      c2out << _("Install these packages without verification?") << std::flush;
-      if (!YnPrompt(false))
+      if (!YnPrompt(_("Install these packages without verification?"), false))
          return _error->Error(_("Some packages could not be authenticated"));
 
       return true;
    }
-   else if (_config->FindB("APT::Get::Force-Yes",false) == true)
+   else if (_config->FindB("APT::Get::Force-Yes",false) == true) {
+      _error->Warning(_("--force-yes is deprecated, use one of the options starting with --allow instead."));
       return true;
+   }
 
-   return _error->Error(_("There are problems and -y was used without --force-yes"));
+   return _error->Error(_("There were unauthenticated packages and -y was used without --allow-unauthenticated"));
 }
                                                                        /*}}}*/
 bool AcquireRun(pkgAcquire &Fetcher, int const PulseInterval, bool * const Failure, bool * const TransientNetworkFailure)/*{{{*/
@@ -146,7 +115,7 @@ bool AcquireRun(pkgAcquire &Fetcher, int const PulseInterval, bool * const Failu
       uri.User.clear();
       uri.Password.clear();
       std::string descUri = std::string(uri);
-      _error->Error(_("Failed to fetch %s  %s\n"), descUri.c_str(),
+      _error->Error(_("Failed to fetch %s  %s"), descUri.c_str(),
            (*I)->ErrorText.c_str());
 
       if (Failure != NULL)
@@ -181,7 +150,7 @@ bool CheckFreeSpaceBeforeDownload(std::string const &Dir, unsigned long long Fet
       {
         struct statfs Stat;
         if (statfs(Dir.c_str(),&Stat) != 0
-#if HAVE_STRUCT_STATFS_F_TYPE
+#ifdef HAVE_STRUCT_STATFS_F_TYPE
               || Stat.f_type != RAMFS_MAGIC
 #endif
            )
@@ -192,3 +161,218 @@ bool CheckFreeSpaceBeforeDownload(std::string const &Dir, unsigned long long Fet
    return true;
 }
                                                                        /*}}}*/
+
+aptAcquireWithTextStatus::aptAcquireWithTextStatus() : pkgAcquire::pkgAcquire(),
+   Stat(std::cout, ScreenWidth, _config->FindI("quiet",0))
+{
+   SetLog(&Stat);
+}
+
+// DoDownload - download a binary                                      /*{{{*/
+bool DoDownload(CommandLine &CmdL)
+{
+   CacheFile Cache;
+   if (Cache.ReadOnlyOpen() == false)
+      return false;
+
+   APT::CacheSetHelper helper;
+   APT::VersionSet verset = APT::VersionSet::FromCommandLine(Cache,
+               CmdL.FileList + 1, APT::CacheSetHelper::CANDIDATE, helper);
+
+   if (verset.empty() == true)
+      return false;
+
+   pkgRecords Recs(Cache);
+   pkgSourceList *SrcList = Cache.GetSourceList();
+
+   // reuse the usual acquire methods for deb files, but don't drop them into
+   // the usual directories - keep everything in the current directory
+   aptAcquireWithTextStatus Fetcher;
+   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)
+   {
+      pkgAcquire::Item *I = new pkgAcqArchive(&Fetcher, SrcList, &Recs, *Ver, storefile[i]);
+      if (storefile[i].empty())
+        continue;
+      std::string const filename = cwd + flNotDir(storefile[i]);
+      storefile[i].assign(filename);
+      I->DestFile.assign(filename);
+   }
+
+   // 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)
+        std::cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile)  << ' ' <<
+              I->Owner->FileSize << ' ' << I->Owner->HashSum() << std::endl;
+      return true;
+   }
+
+   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();
+        chmod(filename.c_str(), 0644);
+      }
+   }
+   return Failed == false;
+}
+                                                                       /*}}}*/
+// DoChangelog - Get changelog from the command line                   /*{{{*/
+bool DoChangelog(CommandLine &CmdL)
+{
+   CacheFile Cache;
+   if (Cache.ReadOnlyOpen() == false)
+      return false;
+
+   APT::CacheSetHelper helper;
+   APT::VersionList verset = APT::VersionList::FromCommandLine(Cache,
+               CmdL.FileList + 1, APT::CacheSetHelper::CANDIDATE, helper);
+   if (verset.empty() == true)
+      return false;
+
+   bool const downOnly = _config->FindB("APT::Get::Download-Only", false);
+   bool const printOnly = _config->FindB("APT::Get::Print-URIs", false);
+   if (printOnly)
+      _config->CndSet("Acquire::Changelogs::AlwaysOnline", true);
+
+   aptAcquireWithTextStatus Fetcher;
+   for (APT::VersionList::const_iterator Ver = verset.begin();
+        Ver != verset.end();
+        ++Ver)
+   {
+      if (printOnly)
+        new pkgAcqChangelog(&Fetcher, Ver, "/dev/null");
+      else if (downOnly)
+        new pkgAcqChangelog(&Fetcher, Ver, ".");
+      else
+        new pkgAcqChangelog(&Fetcher, Ver);
+   }
+
+   if (printOnly == false)
+   {
+      bool Failed = false;
+      if (AcquireRun(Fetcher, 0, &Failed, NULL) == false || Failed == true)
+        return false;
+   }
+
+   if (downOnly == false || printOnly == true)
+   {
+      bool Failed = false;
+      for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); ++I)
+      {
+        if (printOnly)
+        {
+           if ((*I)->ErrorText.empty() == false)
+           {
+              Failed = true;
+              _error->Error("%s", (*I)->ErrorText.c_str());
+           }
+           else
+              std::cout << '\'' << (*I)->DescURI() << "' " << flNotDir((*I)->DestFile)  << std::endl;
+        }
+        else
+           DisplayFileInPager((*I)->DestFile);
+      }
+      return Failed == false;
+   }
+
+   return true;
+}
+                                                                       /*}}}*/
+
+// DoClean - Remove download archives                                  /*{{{*/
+bool DoClean(CommandLine &)
+{
+   std::string const archivedir = _config->FindDir("Dir::Cache::archives");
+   std::string const listsdir = _config->FindDir("Dir::state::lists");
+
+   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");
+      std::cout << "Del " << archivedir << "* " << archivedir << "partial/*"<< std::endl
+          << "Del " << listsdir << "partial/*" << std::endl
+          << "Del " << pkgcache << " " << srcpkgcache << std::endl;
+      return true;
+   }
+
+   pkgAcquire Fetcher;
+   if (archivedir.empty() == false && FileExists(archivedir) == true &&
+        Fetcher.GetLock(archivedir) == true)
+   {
+      Fetcher.Clean(archivedir);
+      Fetcher.Clean(archivedir + "partial/");
+   }
+
+   if (listsdir.empty() == false && FileExists(listsdir) == true &&
+        Fetcher.GetLock(listsdir) == true)
+   {
+      Fetcher.Clean(listsdir + "partial/");
+   }
+
+   pkgCacheFile::RemoveCaches();
+
+   return true;
+}
+                                                                       /*}}}*/
+// DoAutoClean - Smartly remove downloaded archives                    /*{{{*/
+// ---------------------------------------------------------------------
+/* This is similar to clean but it only purges things that cannot be 
+   downloaded, that is old versions of cached packages. */
+ class LogCleaner : public pkgArchiveCleaner
+{
+   protected:
+      virtual void Erase(const char *File, std::string Pkg, std::string Ver,struct stat &St) APT_OVERRIDE
+      {
+        c1out << "Del " << Pkg << " " << Ver << " [" << SizeToStr(St.st_size) << "B]" << std::endl;
+
+        if (_config->FindB("APT::Get::Simulate") == false)
+           RemoveFile("Cleaner::Erase", File);
+      };
+};
+bool DoAutoClean(CommandLine &)
+{
+   std::string const archivedir = _config->FindDir("Dir::Cache::Archives");
+   if (FileExists(archivedir) == false)
+      return true;
+
+   // Lock the archive directory
+   FileFd Lock;
+   if (_config->FindB("Debug::NoLocking",false) == false)
+   {
+      int lock_fd = GetLock(flCombine(archivedir, "lock"));
+      if (lock_fd < 0)
+        return _error->Error(_("Unable to lock the download directory"));
+      Lock.Fd(lock_fd);
+   }
+
+   CacheFile Cache;
+   if (Cache.Open() == false)
+      return false;
+
+   LogCleaner Cleaner;
+
+   return Cleaner.Go(archivedir, *Cache) &&
+      Cleaner.Go(flCombine(archivedir, "partial/"), *Cache);
+}
+                                                                       /*}}}*/