cmdline/apt-get.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: apt-get.cc,v 1.156 2004/08/28 01:05:16 mdz Exp $
   4 /* ######################################################################
   5
   6    apt-get - Cover for dpkg
   7
   8    This is an allout cover for dpkg implementing a safer front end. It is
   9    based largely on libapt-pkg.
  10
  11    The syntax is different,
  12       apt-get [opt] command [things]
  13    Where command is:
  14       update - Resyncronize the package files from their sources
  15       upgrade - Smart-Download the newest versions of all packages
  16       dselect-upgrade - Follows dselect's changes to the Status: field
  17                        and installes new and removes old packages
  18       dist-upgrade - Powerfull upgrader designed to handle the issues with
  19                     a new distribution.
  20       install - Download and install a given package (by name, not by .deb)
  21       check - Update the package cache and check for broken packages
  22       clean - Erase the .debs downloaded to /var/cache/apt/archives and
  23               the partial dir too
  24
  25    ##################################################################### */
  26                                                                         /*}}}*/
  27 // Include Files                                                        /*{{{*/
  28 #include <config.h>
  29
  30 #include <apt-pkg/aptconfiguration.h>
  31 #include <apt-pkg/error.h>
  32 #include <apt-pkg/cmndline.h>
  33 #include <apt-pkg/init.h>
  34 #include <apt-pkg/depcache.h>
  35 #include <apt-pkg/sourcelist.h>
  36 #include <apt-pkg/algorithms.h>
  37 #include <apt-pkg/acquire-item.h>
  38 #include <apt-pkg/strutl.h>
  39 #include <apt-pkg/fileutl.h>
  40 #include <apt-pkg/clean.h>
  41 #include <apt-pkg/srcrecords.h>
  42 #include <apt-pkg/version.h>
  43 #include <apt-pkg/cachefile.h>
  44 #include <apt-pkg/cacheset.h>
  45 #include <apt-pkg/sptr.h>
  46 #include <apt-pkg/md5.h>
  47 #include <apt-pkg/versionmatch.h>
  48 #include <apt-pkg/progress.h>
  49 #include <apt-pkg/pkgsystem.h>
  50 #include <apt-pkg/pkgrecords.h>
  51 #include <apt-pkg/indexfile.h>
  52 #include <apt-pkg/upgrade.h>
  53 #include <apt-pkg/metaindex.h>
  54 #include <apt-pkg/indexrecords.h>
  55
  56 #include <apt-private/private-download.h>
  57 #include <apt-private/private-install.h>
  58 #include <apt-private/private-upgrade.h>
  59 #include <apt-private/private-output.h>
  60 #include <apt-private/private-cacheset.h>
  61 #include <apt-private/private-update.h>
  62 #include <apt-private/private-cmndline.h>
  63 #include <apt-private/private-moo.h>
  64 #include <apt-private/private-utils.h>
  65
  66 #include <apt-private/acqprogress.h>
  67
  68 #include <set>
  69 #include <fstream>
  70 #include <sstream>
  71
  72 #include <locale.h>
  73 #include <langinfo.h>
  74 #include <termios.h>
  75 #include <sys/ioctl.h>
  76 #include <sys/stat.h>
  77 #include <sys/statfs.h>
  78 #include <sys/statvfs.h>
  79 #include <signal.h>
  80 #include <unistd.h>
  81 #include <stdio.h>
  82 #include <errno.h>
  83 #include <regex.h>
  84 #include <sys/wait.h>
  85
  86 #include <apt-private/private-output.h>
  87 #include <apt-private/private-main.h>
  88
  89 #include <apti18n.h>
  90                                                                         /*}}}*/
  91
  92 using namespace std;
  93
  94 // TryToInstallBuildDep - Try to install a single package               /*{{{*/
  95 // ---------------------------------------------------------------------
  96 /* This used to be inlined in DoInstall, but with the advent of regex package
  97    name matching it was split out.. */
  98 bool TryToInstallBuildDep(pkgCache::PkgIterator Pkg,pkgCacheFile &Cache,
  99                   pkgProblemResolver &Fix,bool Remove,bool BrokenFix,
 100                   bool AllowFail = true)
 101 {
 102    if (Cache[Pkg].CandidateVer == 0 && Pkg->ProvidesList != 0)
 103    {
 104       CacheSetHelperAPTGet helper(c1out);
 105       helper.showErrors(false);
 106       pkgCache::VerIterator Ver = helper.canNotFindNewestVer(Cache, Pkg);
 107       if (Ver.end() == false)
 108          Pkg = Ver.ParentPkg();
 109       else if (helper.showVirtualPackageErrors(Cache) == false)
 110          return AllowFail;
 111    }
 112
 113    if (_config->FindB("Debug::BuildDeps",false) == true)
 114    {
 115       if (Remove == true)
 116          cout << "  Trying to remove " << Pkg << endl;
 117       else
 118          cout << "  Trying to install " << Pkg << endl;
 119    }
 120
 121    if (Remove == true)
 122    {
 123       TryToRemove RemoveAction(Cache, &Fix);
 124       RemoveAction(Pkg.VersionList());
 125    } else if (Cache[Pkg].CandidateVer != 0) {
 126       TryToInstall InstallAction(Cache, &Fix, BrokenFix);
 127       InstallAction(Cache[Pkg].CandidateVerIter(Cache));
 128       InstallAction.doAutoInstall();
 129    } else
 130       return AllowFail;
 131
 132    return true;
 133 }
 134                                                                         /*}}}*/
 135 // FindSrc - Find a source record                                       /*{{{*/
 136 // ---------------------------------------------------------------------
 137 /* */
 138 pkgSrcRecords::Parser *FindSrc(const char *Name,pkgRecords &Recs,
 139                                pkgSrcRecords &SrcRecs,string &Src,
 140                                CacheFile &CacheFile)
 141 {
 142    string VerTag;
 143    string DefRel = _config->Find("APT::Default-Release");
 144    string TmpSrc = Name;
 145    pkgDepCache *Cache = CacheFile.GetDepCache();
 146
 147    // extract the version/release from the pkgname
 148    const size_t found = TmpSrc.find_last_of("/=");
 149    if (found != string::npos) {
 150       if (TmpSrc[found] == '/')
 151          DefRel = TmpSrc.substr(found+1);
 152       else
 153          VerTag = TmpSrc.substr(found+1);
 154       TmpSrc = TmpSrc.substr(0,found);
 155    }
 156
 157    /* Lookup the version of the package we would install if we were to
 158       install a version and determine the source package name, then look
 159       in the archive for a source package of the same name. */
 160    bool MatchSrcOnly = _config->FindB("APT::Get::Only-Source");
 161    const pkgCache::PkgIterator Pkg = Cache->FindPkg(TmpSrc);
 162    if (MatchSrcOnly == false && Pkg.end() == false)
 163    {
 164       if(VerTag.empty() == false || DefRel.empty() == false)
 165       {
 166          bool fuzzy = false;
 167          // we have a default release, try to locate the pkg. we do it like
 168          // this because GetCandidateVer() will not "downgrade", that means
 169          // "apt-get source -t stable apt" won't work on a unstable system
 170          for (pkgCache::VerIterator Ver = Pkg.VersionList();; ++Ver)
 171          {
 172             // try first only exact matches, later fuzzy matches
 173             if (Ver.end() == true)
 174             {
 175                if (fuzzy == true)
 176                   break;
 177                fuzzy = true;
 178                Ver = Pkg.VersionList();
 179                // exit right away from the Pkg.VersionList() loop if we
 180                // don't have any versions
 181                if (Ver.end() == true)
 182                   break;
 183             }
 184             // We match against a concrete version (or a part of this version)
 185             if (VerTag.empty() == false &&
 186                 (fuzzy == true || Cache->VS().CmpVersion(VerTag, Ver.VerStr()) != 0) && // exact match
 187                 (fuzzy == false || strncmp(VerTag.c_str(), Ver.VerStr(), VerTag.size()) != 0)) // fuzzy match
 188                continue;
 189
 190             for (pkgCache::VerFileIterator VF = Ver.FileList();
 191                  VF.end() == false; ++VF)
 192             {
 193                /* If this is the status file, and the current version is not the
 194                   version in the status file (ie it is not installed, or somesuch)
 195                   then it is not a candidate for installation, ever. This weeds
 196                   out bogus entries that may be due to config-file states, or
 197                   other. */
 198                if ((VF.File()->Flags & pkgCache::Flag::NotSource) ==
 199                    pkgCache::Flag::NotSource && Pkg.CurrentVer() != Ver)
 200                   continue;
 201
 202                // or we match against a release
 203                if(VerTag.empty() == false ||
 204                   (VF.File().Archive() != 0 && VF.File().Archive() == DefRel) ||
 205                   (VF.File().Codename() != 0 && VF.File().Codename() == DefRel))
 206                {
 207                   pkgRecords::Parser &Parse = Recs.Lookup(VF);
 208                   Src = Parse.SourcePkg();
 209                   // no SourcePkg name, so it is the "binary" name
 210                   if (Src.empty() == true)
 211                      Src = TmpSrc;
 212                   // the Version we have is possibly fuzzy or includes binUploads,
 213                   // so we use the Version of the SourcePkg (empty if same as package)
 214                   VerTag = Parse.SourceVer();
 215                   if (VerTag.empty() == true)
 216                      VerTag = Ver.VerStr();
 217                   break;
 218                }
 219             }
 220             if (Src.empty() == false)
 221                break;
 222          }
 223 #if 0
 224          if (Src.empty() == true)
 225          {
 226             // Sources files have no codename information
 227             if (VerTag.empty() == true && DefRel.empty() == false)
 228             {
 229                _error->Warning(_("Ignore unavailable target release '%s' of package '%s'"), DefRel.c_str(), TmpSrc.c_str());
 230                return 0;
 231             }
 232          }
 233 #endif
 234       }
 235       if (Src.empty() == true)
 236       {
 237          // if we don't have found a fitting package yet so we will
 238          // choose a good candidate and proceed with that.
 239          // Maybe we will find a source later on with the right VerTag
 240          pkgCache::VerIterator Ver = Cache->GetCandidateVer(Pkg);
 241          if (Ver.end() == false)
 242          {
 243             pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
 244             Src = Parse.SourcePkg();
 245             if (VerTag.empty() == true)
 246                VerTag = Parse.SourceVer();
 247          }
 248       }
 249    }
 250
 251    if (Src.empty() == true)
 252       Src = TmpSrc;
 253    else
 254    {
 255       /* if we have a source pkg name, make sure to only search
 256          for srcpkg names, otherwise apt gets confused if there
 257          is a binary package "pkg1" and a source package "pkg1"
 258          with the same name but that comes from different packages */
 259       MatchSrcOnly = true;
 260       if (Src != TmpSrc)
 261       {
 262          ioprintf(c1out, _("Picking '%s' as source package instead of '%s'\n"), Src.c_str(), TmpSrc.c_str());
 263       }
 264    }
 265
 266    // The best hit
 267    pkgSrcRecords::Parser *Last = 0;
 268    unsigned long Offset = 0;
 269    string Version;
 270    string FoundRel;
 271
 272    /* Iterate over all of the hits, which includes the resulting
 273       binary packages in the search */
 274    pkgSrcRecords::Parser *Parse;
 275    while (true)
 276    {
 277       SrcRecs.Restart();
 278       while ((Parse = SrcRecs.Find(Src.c_str(), MatchSrcOnly)) != 0)
 279       {
 280          const string Ver = Parse->Version();
 281
 282
 283          // find release
 284          const pkgIndexFile& SI = Parse->Index();
 285          pkgSourceList *SrcList = CacheFile.GetSourceList();
 286          for (pkgSourceList::const_iterator S = SrcList->begin();
 287               S != SrcList->end(); ++S)
 288          {
 289             vector<pkgIndexFile *> *Indexes = (*S)->GetIndexFiles();
 290             for (vector<pkgIndexFile *>::const_iterator IF = Indexes->begin();
 291                  IF != Indexes->end(); ++IF)
 292             {
 293                if (&SI == (*IF))
 294                {
 295                   std::string dirname = _config->FindDir("Dir::State::lists");
 296                   std::string path;
 297                   path = dirname + URItoFileName((*S)->GetURI()) + "dists_" + (*S)->GetDist() + "_Release";
 298                   if (!FileExists(path))
 299                      path = dirname + URItoFileName((*S)->GetURI()) + "dists_" + (*S)->GetDist() + "_InRelease";
 300                   indexRecords records;
 301                   records.Load(path);
 302                   if (records.GetSuite() == DefRel)
 303                   {
 304                      ioprintf(clog, "Selectied version '%s' (%s) for %s\n",
 305                               Ver.c_str(), DefRel.c_str(), Src.c_str());
 306                      Last = Parse;
 307                      Offset = Parse->Offset();
 308                      Version = Ver;
 309                      FoundRel = DefRel;
 310                      break;
 311                   }
 312                }
 313             }
 314          }
 315          if (DefRel.empty() == false && (DefRel == FoundRel))
 316             break;
 317
 318          // Ignore all versions which doesn't fit
 319          if (VerTag.empty() == false &&
 320              Cache->VS().CmpVersion(VerTag, Ver) != 0) // exact match
 321             continue;
 322
 323          // Newer version or an exact match? Save the hit
 324          if (Last == 0 || Cache->VS().CmpVersion(Version,Ver) < 0) {
 325             Last = Parse;
 326             Offset = Parse->Offset();
 327             Version = Ver;
 328          }
 329
 330          // was the version check above an exact match? If so, we don't need to look further
 331          if (VerTag.empty() == false && (VerTag == Ver))
 332          {
 333             break;
 334          }
 335       }
 336       if (Last != 0 || VerTag.empty() == true)
 337          break;
 338       return 0;
 339    }
 340
 341    if (Last == 0 || Last->Jump(Offset) == false)
 342       return 0;
 343
 344    return Last;
 345 }
 346                                                                         /*}}}*/
 347 /* mark packages as automatically/manually installed.                   {{{*/
 348 bool DoMarkAuto(CommandLine &CmdL)
 349 {
 350    bool Action = true;
 351    int AutoMarkChanged = 0;
 352    OpTextProgress progress;
 353    CacheFile Cache;
 354    if (Cache.Open() == false)
 355       return false;
 356
 357    if (strcasecmp(CmdL.FileList[0],"markauto") == 0)
 358       Action = true;
 359    else if (strcasecmp(CmdL.FileList[0],"unmarkauto") == 0)
 360       Action = false;
 361
 362    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
 363    {
 364       const char *S = *I;
 365       // Locate the package
 366       pkgCache::PkgIterator Pkg = Cache->FindPkg(S);
 367       if (Pkg.end() == true) {
 368          return _error->Error(_("Couldn't find package %s"),S);
 369       }
 370       else
 371       {
 372          if (!Action)
 373             ioprintf(c1out,_("%s set to manually installed.\n"), Pkg.Name());
 374          else
 375             ioprintf(c1out,_("%s set to automatically installed.\n"),
 376                       Pkg.Name());
 377
 378          Cache->MarkAuto(Pkg,Action);
 379          AutoMarkChanged++;
 380       }
 381    }
 382
 383    _error->Notice(_("This command is deprecated. Please use 'apt-mark auto' and 'apt-mark manual' instead."));
 384
 385    if (AutoMarkChanged && ! _config->FindB("APT::Get::Simulate",false))
 386       return Cache->writeStateFile(NULL);
 387    return false;
 388 }
 389                                                                         /*}}}*/
 390 // DoDSelectUpgrade - Do an upgrade by following dselects selections    /*{{{*/
 391 // ---------------------------------------------------------------------
 392 /* Follows dselect's selections */
 393 bool DoDSelectUpgrade(CommandLine &CmdL)
 394 {
 395    CacheFile Cache;
 396    if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
 397       return false;
 398
 399    pkgDepCache::ActionGroup group(Cache);
 400
 401    // Install everything with the install flag set
 402    pkgCache::PkgIterator I = Cache->PkgBegin();
 403    for (;I.end() != true; ++I)
 404    {
 405       /* Install the package only if it is a new install, the autoupgrader
 406          will deal with the rest */
 407       if (I->SelectedState == pkgCache::State::Install)
 408          Cache->MarkInstall(I,false);
 409    }
 410
 411    /* Now install their deps too, if we do this above then order of
 412       the status file is significant for | groups */
 413    for (I = Cache->PkgBegin();I.end() != true; ++I)
 414    {
 415       /* Install the package only if it is a new install, the autoupgrader
 416          will deal with the rest */
 417       if (I->SelectedState == pkgCache::State::Install)
 418          Cache->MarkInstall(I,true);
 419    }
 420
 421    // Apply erasures now, they override everything else.
 422    for (I = Cache->PkgBegin();I.end() != true; ++I)
 423    {
 424       // Remove packages
 425       if (I->SelectedState == pkgCache::State::DeInstall ||
 426           I->SelectedState == pkgCache::State::Purge)
 427          Cache->MarkDelete(I,I->SelectedState == pkgCache::State::Purge);
 428    }
 429
 430    /* Resolve any problems that dselect created, allupgrade cannot handle
 431       such things. We do so quite agressively too.. */
 432    if (Cache->BrokenCount() != 0)
 433    {
 434       pkgProblemResolver Fix(Cache);
 435
 436       // Hold back held packages.
 437       if (_config->FindB("APT::Ignore-Hold",false) == false)
 438       {
 439          for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; ++I)
 440          {
 441             if (I->SelectedState == pkgCache::State::Hold)
 442             {
 443                Fix.Protect(I);
 444                Cache->MarkKeep(I);
 445             }
 446          }
 447       }
 448
 449       if (Fix.Resolve() == false)
 450       {
 451          ShowBroken(c1out,Cache,false);
 452          return _error->Error(_("Internal error, problem resolver broke stuff"));
 453       }
 454    }
 455
 456    // Now upgrade everything
 457    if (pkgAllUpgrade(Cache) == false)
 458    {
 459       ShowBroken(c1out,Cache,false);
 460       return _error->Error(_("Internal error, problem resolver broke stuff"));
 461    }
 462
 463    return InstallPackages(Cache,false);
 464 }
 465                                                                         /*}}}*/
 466 // DoClean - Remove download archives                                   /*{{{*/
 467 // ---------------------------------------------------------------------
 468 /* */
 469 bool DoClean(CommandLine &CmdL)
 470 {
 471    std::string const archivedir = _config->FindDir("Dir::Cache::archives");
 472    std::string const pkgcache = _config->FindFile("Dir::cache::pkgcache");
 473    std::string const srcpkgcache = _config->FindFile("Dir::cache::srcpkgcache");
 474
 475    if (_config->FindB("APT::Get::Simulate") == true)
 476    {
 477       cout << "Del " << archivedir << "* " << archivedir << "partial/*"<< endl
 478            << "Del " << pkgcache << " " << srcpkgcache << endl;
 479       return true;
 480    }
 481
 482    // Lock the archive directory
 483    FileFd Lock;
 484    if (_config->FindB("Debug::NoLocking",false) == false)
 485    {
 486       int lock_fd = GetLock(archivedir + "lock");
 487       if (lock_fd < 0)
 488          return _error->Error(_("Unable to lock the download directory"));
 489       Lock.Fd(lock_fd);
 490    }
 491
 492    pkgAcquire Fetcher;
 493    Fetcher.Clean(archivedir);
 494    Fetcher.Clean(archivedir + "partial/");
 495
 496    pkgCacheFile::RemoveCaches();
 497
 498    return true;
 499 }
 500                                                                         /*}}}*/
 501 // DoAutoClean - Smartly remove downloaded archives                     /*{{{*/
 502 // ---------------------------------------------------------------------
 503 /* This is similar to clean but it only purges things that cannot be
 504    downloaded, that is old versions of cached packages. */
 505 class LogCleaner : public pkgArchiveCleaner
 506 {
 507    protected:
 508    virtual void Erase(const char *File,string Pkg,string Ver,struct stat &St)
 509    {
 510       c1out << "Del " << Pkg << " " << Ver << " [" << SizeToStr(St.st_size) << "B]" << endl;
 511
 512       if (_config->FindB("APT::Get::Simulate") == false)
 513          unlink(File);
 514    };
 515 };
 516
 517 bool DoAutoClean(CommandLine &CmdL)
 518 {
 519    // Lock the archive directory
 520    FileFd Lock;
 521    if (_config->FindB("Debug::NoLocking",false) == false)
 522    {
 523       int lock_fd = GetLock(_config->FindDir("Dir::Cache::Archives") + "lock");
 524       if (lock_fd < 0)
 525          return _error->Error(_("Unable to lock the download directory"));
 526       Lock.Fd(lock_fd);
 527    }
 528
 529    CacheFile Cache;
 530    if (Cache.Open() == false)
 531       return false;
 532
 533    LogCleaner Cleaner;
 534
 535    return Cleaner.Go(_config->FindDir("Dir::Cache::archives"),*Cache) &&
 536       Cleaner.Go(_config->FindDir("Dir::Cache::archives") + "partial/",*Cache);
 537 }
 538                                                                         /*}}}*/
 539 // DoDownload - download a binary                                       /*{{{*/
 540 // ---------------------------------------------------------------------
 541 bool DoDownload(CommandLine &CmdL)
 542 {
 543    CacheFile Cache;
 544    if (Cache.ReadOnlyOpen() == false)
 545       return false;
 546
 547    APT::CacheSetHelper helper(c0out);
 548    APT::VersionList verset = APT::VersionList::FromCommandLine(Cache,
 549                 CmdL.FileList + 1, APT::VersionList::CANDIDATE, helper);
 550
 551    if (verset.empty() == true)
 552       return false;
 553
 554    AcqTextStatus Stat(ScreenWidth, _config->FindI("quiet", 0));
 555    pkgAcquire Fetcher;
 556    if (Fetcher.Setup(&Stat) == false)
 557       return false;
 558
 559    pkgRecords Recs(Cache);
 560    pkgSourceList *SrcList = Cache.GetSourceList();
 561
 562    // reuse the usual acquire methods for deb files, but don't drop them into
 563    // the usual directories - keep everything in the current directory
 564    std::vector<std::string> storefile(verset.size());
 565    std::string const cwd = SafeGetCWD();
 566    _config->Set("Dir::Cache::Archives", cwd);
 567    int i = 0;
 568    for (APT::VersionList::const_iterator Ver = verset.begin();
 569          Ver != verset.end(); ++Ver, ++i)
 570    {
 571       pkgAcquire::Item *I = new pkgAcqArchive(&Fetcher, SrcList, &Recs, *Ver, storefile[i]);
 572       std::string const filename = cwd + flNotDir(storefile[i]);
 573       storefile[i].assign(filename);
 574       I->DestFile.assign(filename);
 575    }
 576
 577    // Just print out the uris and exit if the --print-uris flag was used
 578    if (_config->FindB("APT::Get::Print-URIs") == true)
 579    {
 580       pkgAcquire::UriIterator I = Fetcher.UriBegin();
 581       for (; I != Fetcher.UriEnd(); ++I)
 582          cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
 583                I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
 584       return true;
 585    }
 586
 587    if (_error->PendingError() == true || CheckAuth(Fetcher, false) == false)
 588       return false;
 589
 590    bool Failed = false;
 591    if (AcquireRun(Fetcher, 0, &Failed, NULL) == false)
 592       return false;
 593
 594    // copy files in local sources to the current directory
 595    for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); ++I)
 596       if ((*I)->Local == true && (*I)->Status == pkgAcquire::Item::StatDone)
 597       {
 598          std::string const filename = cwd + flNotDir((*I)->DestFile);
 599          std::ifstream src((*I)->DestFile.c_str(), std::ios::binary);
 600          std::ofstream dst(filename.c_str(), std::ios::binary);
 601          dst << src.rdbuf();
 602       }
 603
 604    return Failed == false;
 605 }
 606                                                                         /*}}}*/
 607 // DoCheck - Perform the check operation                                /*{{{*/
 608 // ---------------------------------------------------------------------
 609 /* Opening automatically checks the system, this command is mostly used
 610    for debugging */
 611 bool DoCheck(CommandLine &CmdL)
 612 {
 613    CacheFile Cache;
 614    Cache.Open();
 615    Cache.CheckDeps();
 616
 617    return true;
 618 }
 619                                                                         /*}}}*/
 620 // DoSource - Fetch a source archive                                    /*{{{*/
 621 // ---------------------------------------------------------------------
 622 /* Fetch souce packages */
 623 struct DscFile
 624 {
 625    string Package;
 626    string Version;
 627    string Dsc;
 628 };
 629
 630 bool DoSource(CommandLine &CmdL)
 631 {
 632    CacheFile Cache;
 633    if (Cache.Open(false) == false)
 634       return false;
 635
 636    if (CmdL.FileSize() <= 1)
 637       return _error->Error(_("Must specify at least one package to fetch source for"));
 638
 639    // Read the source list
 640    if (Cache.BuildSourceList() == false)
 641       return false;
 642    pkgSourceList *List = Cache.GetSourceList();
 643
 644    // Create the text record parsers
 645    pkgRecords Recs(Cache);
 646    pkgSrcRecords SrcRecs(*List);
 647    if (_error->PendingError() == true)
 648       return false;
 649
 650    // Create the download object
 651    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
 652    pkgAcquire Fetcher;
 653    Fetcher.SetLog(&Stat);
 654
 655    DscFile *Dsc = new DscFile[CmdL.FileSize()];
 656
 657    // insert all downloaded uris into this set to avoid downloading them
 658    // twice
 659    set<string> queued;
 660
 661    // Diff only mode only fetches .diff files
 662    bool const diffOnly = _config->FindB("APT::Get::Diff-Only", false);
 663    // Tar only mode only fetches .tar files
 664    bool const tarOnly = _config->FindB("APT::Get::Tar-Only", false);
 665    // Dsc only mode only fetches .dsc files
 666    bool const dscOnly = _config->FindB("APT::Get::Dsc-Only", false);
 667
 668    // Load the requestd sources into the fetcher
 669    unsigned J = 0;
 670    for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
 671    {
 672       string Src;
 673       pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,Cache);
 674
 675       if (Last == 0) {
 676          delete[] Dsc;
 677          return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
 678       }
 679
 680       string srec = Last->AsStr();
 681       string::size_type pos = srec.find("\nVcs-");
 682       while (pos != string::npos)
 683       {
 684          pos += strlen("\nVcs-");
 685          string vcs = srec.substr(pos,srec.find(":",pos)-pos);
 686          if(vcs == "Browser")
 687          {
 688             pos = srec.find("\nVcs-", pos);
 689             continue;
 690          }
 691          pos += vcs.length()+2;
 692          string::size_type epos = srec.find("\n", pos);
 693          string uri = srec.substr(pos,epos-pos).c_str();
 694          ioprintf(c1out, _("NOTICE: '%s' packaging is maintained in "
 695                            "the '%s' version control system at:\n"
 696                            "%s\n"),
 697                   Src.c_str(), vcs.c_str(), uri.c_str());
 698          if(vcs == "Bzr")
 699             ioprintf(c1out,_("Please use:\n"
 700                              "bzr branch %s\n"
 701                              "to retrieve the latest (possibly unreleased) "
 702                              "updates to the package.\n"),
 703                      uri.c_str());
 704          break;
 705       }
 706
 707       // Back track
 708       vector<pkgSrcRecords::File> Lst;
 709       if (Last->Files(Lst) == false) {
 710          delete[] Dsc;
 711          return false;
 712       }
 713
 714       // Load them into the fetcher
 715       for (vector<pkgSrcRecords::File>::const_iterator I = Lst.begin();
 716            I != Lst.end(); ++I)
 717       {
 718          // Try to guess what sort of file it is we are getting.
 719          if (I->Type == "dsc")
 720          {
 721             Dsc[J].Package = Last->Package();
 722             Dsc[J].Version = Last->Version();
 723             Dsc[J].Dsc = flNotDir(I->Path);
 724          }
 725
 726          // Handle the only options so that multiple can be used at once
 727          if (diffOnly == true || tarOnly == true || dscOnly == true)
 728          {
 729             if ((diffOnly == true && I->Type == "diff") ||
 730                 (tarOnly == true && I->Type == "tar") ||
 731                 (dscOnly == true && I->Type == "dsc"))
 732                 ; // Fine, we want this file downloaded
 733             else
 734                continue;
 735          }
 736
 737          // don't download the same uri twice (should this be moved to
 738          // the fetcher interface itself?)
 739          if(queued.find(Last->Index().ArchiveURI(I->Path)) != queued.end())
 740             continue;
 741          queued.insert(Last->Index().ArchiveURI(I->Path));
 742
 743          // check if we have a file with that md5 sum already localy
 744          if(!I->MD5Hash.empty() && FileExists(flNotDir(I->Path)))
 745          {
 746             FileFd Fd(flNotDir(I->Path), FileFd::ReadOnly);
 747             MD5Summation sum;
 748             sum.AddFD(Fd.Fd(), Fd.Size());
 749             Fd.Close();
 750             if((string)sum.Result() == I->MD5Hash)
 751             {
 752                ioprintf(c1out,_("Skipping already downloaded file '%s'\n"),
 753                         flNotDir(I->Path).c_str());
 754                continue;
 755             }
 756          }
 757
 758          new pkgAcqFile(&Fetcher,Last->Index().ArchiveURI(I->Path),
 759                         I->MD5Hash,I->Size,
 760                         Last->Index().SourceInfo(*Last,*I),Src);
 761       }
 762    }
 763
 764    // Display statistics
 765    unsigned long long FetchBytes = Fetcher.FetchNeeded();
 766    unsigned long long FetchPBytes = Fetcher.PartialPresent();
 767    unsigned long long DebBytes = Fetcher.TotalNeeded();
 768
 769    // Check for enough free space
 770    struct statvfs Buf;
 771    string OutputDir = ".";
 772    if (statvfs(OutputDir.c_str(),&Buf) != 0) {
 773       delete[] Dsc;
 774       if (errno == EOVERFLOW)
 775          return _error->WarningE("statvfs",_("Couldn't determine free space in %s"),
 776                                 OutputDir.c_str());
 777       else
 778          return _error->Errno("statvfs",_("Couldn't determine free space in %s"),
 779                                 OutputDir.c_str());
 780    } else if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
 781      {
 782        struct statfs Stat;
 783        if (statfs(OutputDir.c_str(),&Stat) != 0
 784 #if HAVE_STRUCT_STATFS_F_TYPE
 785            || unsigned(Stat.f_type) != RAMFS_MAGIC
 786 #endif
 787            )  {
 788          delete[] Dsc;
 789           return _error->Error(_("You don't have enough free space in %s"),
 790               OutputDir.c_str());
 791        }
 792      }
 793
 794    // Number of bytes
 795    if (DebBytes != FetchBytes)
 796       //TRANSLATOR: The required space between number and unit is already included
 797       // in the replacement strings, so %sB will be correctly translate in e.g. 1,5 MB
 798       ioprintf(c1out,_("Need to get %sB/%sB of source archives.\n"),
 799                SizeToStr(FetchBytes).c_str(),SizeToStr(DebBytes).c_str());
 800    else
 801       //TRANSLATOR: The required space between number and unit is already included
 802       // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
 803       ioprintf(c1out,_("Need to get %sB of source archives.\n"),
 804                SizeToStr(DebBytes).c_str());
 805
 806    if (_config->FindB("APT::Get::Simulate",false) == true)
 807    {
 808       for (unsigned I = 0; I != J; I++)
 809          ioprintf(cout,_("Fetch source %s\n"),Dsc[I].Package.c_str());
 810       delete[] Dsc;
 811       return true;
 812    }
 813
 814    // Just print out the uris an exit if the --print-uris flag was used
 815    if (_config->FindB("APT::Get::Print-URIs") == true)
 816    {
 817       pkgAcquire::UriIterator I = Fetcher.UriBegin();
 818       for (; I != Fetcher.UriEnd(); ++I)
 819          cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
 820                I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
 821       delete[] Dsc;
 822       return true;
 823    }
 824
 825    // Run it
 826    bool Failed = false;
 827    if (AcquireRun(Fetcher, 0, &Failed, NULL) == false || Failed == true)
 828    {
 829       delete[] Dsc;
 830       return _error->Error(_("Failed to fetch some archives."));
 831    }
 832
 833    if (_config->FindB("APT::Get::Download-only",false) == true)
 834    {
 835       c1out << _("Download complete and in download only mode") << endl;
 836       delete[] Dsc;
 837       return true;
 838    }
 839
 840    // Unpack the sources
 841    pid_t Process = ExecFork();
 842
 843    if (Process == 0)
 844    {
 845       bool const fixBroken = _config->FindB("APT::Get::Fix-Broken", false);
 846       for (unsigned I = 0; I != J; ++I)
 847       {
 848          string Dir = Dsc[I].Package + '-' + Cache->VS().UpstreamVersion(Dsc[I].Version.c_str());
 849
 850          // Diff only mode only fetches .diff files
 851          if (_config->FindB("APT::Get::Diff-Only",false) == true ||
 852              _config->FindB("APT::Get::Tar-Only",false) == true ||
 853              Dsc[I].Dsc.empty() == true)
 854             continue;
 855
 856          // See if the package is already unpacked
 857          struct stat Stat;
 858          if (fixBroken == false && stat(Dir.c_str(),&Stat) == 0 &&
 859              S_ISDIR(Stat.st_mode) != 0)
 860          {
 861             ioprintf(c0out ,_("Skipping unpack of already unpacked source in %s\n"),
 862                               Dir.c_str());
 863          }
 864          else
 865          {
 866             // Call dpkg-source
 867             char S[500];
 868             snprintf(S,sizeof(S),"%s -x %s",
 869                      _config->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(),
 870                      Dsc[I].Dsc.c_str());
 871             if (system(S) != 0)
 872             {
 873                fprintf(stderr,_("Unpack command '%s' failed.\n"),S);
 874                fprintf(stderr,_("Check if the 'dpkg-dev' package is installed.\n"));
 875                _exit(1);
 876             }
 877          }
 878
 879          // Try to compile it with dpkg-buildpackage
 880          if (_config->FindB("APT::Get::Compile",false) == true)
 881          {
 882             string buildopts = _config->Find("APT::Get::Host-Architecture");
 883             if (buildopts.empty() == false)
 884                buildopts = "-a" + buildopts + " ";
 885             buildopts.append(_config->Find("DPkg::Build-Options","-b -uc"));
 886
 887             // Call dpkg-buildpackage
 888             char S[500];
 889             snprintf(S,sizeof(S),"cd %s && %s %s",
 890                      Dir.c_str(),
 891                      _config->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(),
 892                      buildopts.c_str());
 893
 894             if (system(S) != 0)
 895             {
 896                fprintf(stderr,_("Build command '%s' failed.\n"),S);
 897                _exit(1);
 898             }
 899          }
 900       }
 901
 902       _exit(0);
 903    }
 904    delete[] Dsc;
 905
 906    // Wait for the subprocess
 907    int Status = 0;
 908    while (waitpid(Process,&Status,0) != Process)
 909    {
 910       if (errno == EINTR)
 911          continue;
 912       return _error->Errno("waitpid","Couldn't wait for subprocess");
 913    }
 914
 915    if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
 916       return _error->Error(_("Child process failed"));
 917
 918    return true;
 919 }
 920                                                                         /*}}}*/
 921 // DoBuildDep - Install/removes packages to satisfy build dependencies  /*{{{*/
 922 // ---------------------------------------------------------------------
 923 /* This function will look at the build depends list of the given source
 924    package and install the necessary packages to make it true, or fail. */
 925 bool DoBuildDep(CommandLine &CmdL)
 926 {
 927    CacheFile Cache;
 928
 929    _config->Set("APT::Install-Recommends", false);
 930
 931    if (Cache.Open(true) == false)
 932       return false;
 933
 934    if (CmdL.FileSize() <= 1)
 935       return _error->Error(_("Must specify at least one package to check builddeps for"));
 936
 937    // Read the source list
 938    if (Cache.BuildSourceList() == false)
 939       return false;
 940    pkgSourceList *List = Cache.GetSourceList();
 941
 942    // Create the text record parsers
 943    pkgRecords Recs(Cache);
 944    pkgSrcRecords SrcRecs(*List);
 945    if (_error->PendingError() == true)
 946       return false;
 947
 948    // Create the download object
 949    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
 950    pkgAcquire Fetcher;
 951    if (Fetcher.Setup(&Stat) == false)
 952       return false;
 953
 954    bool StripMultiArch;
 955    string hostArch = _config->Find("APT::Get::Host-Architecture");
 956    if (hostArch.empty() == false)
 957    {
 958       std::vector<std::string> archs = APT::Configuration::getArchitectures();
 959       if (std::find(archs.begin(), archs.end(), hostArch) == archs.end())
 960          return _error->Error(_("No architecture information available for %s. See apt.conf(5) APT::Architectures for setup"), hostArch.c_str());
 961       StripMultiArch = false;
 962    }
 963    else
 964       StripMultiArch = true;
 965
 966    unsigned J = 0;
 967    for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
 968    {
 969       string Src;
 970       pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,Cache);
 971       if (Last == 0)
 972          return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
 973
 974       // Process the build-dependencies
 975       vector<pkgSrcRecords::Parser::BuildDepRec> BuildDeps;
 976       // FIXME: Can't specify architecture to use for [wildcard] matching, so switch default arch temporary
 977       if (hostArch.empty() == false)
 978       {
 979          std::string nativeArch = _config->Find("APT::Architecture");
 980          _config->Set("APT::Architecture", hostArch);
 981          bool Success = Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only", false), StripMultiArch);
 982          _config->Set("APT::Architecture", nativeArch);
 983          if (Success == false)
 984             return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());
 985       }
 986       else if (Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only", false), StripMultiArch) == false)
 987             return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());
 988
 989       // Also ensure that build-essential packages are present
 990       Configuration::Item const *Opts = _config->Tree("APT::Build-Essential");
 991       if (Opts)
 992          Opts = Opts->Child;
 993       for (; Opts; Opts = Opts->Next)
 994       {
 995          if (Opts->Value.empty() == true)
 996             continue;
 997
 998          pkgSrcRecords::Parser::BuildDepRec rec;
 999          rec.Package = Opts->Value;
1000          rec.Type = pkgSrcRecords::Parser::BuildDependIndep;
1001          rec.Op = 0;
1002          BuildDeps.push_back(rec);
1003       }
1004
1005       if (BuildDeps.empty() == true)
1006       {
1007          ioprintf(c1out,_("%s has no build depends.\n"),Src.c_str());
1008          continue;
1009       }
1010
1011       // Install the requested packages
1012       vector <pkgSrcRecords::Parser::BuildDepRec>::iterator D;
1013       pkgProblemResolver Fix(Cache);
1014       bool skipAlternatives = false; // skip remaining alternatives in an or group
1015       for (D = BuildDeps.begin(); D != BuildDeps.end(); ++D)
1016       {
1017          bool hasAlternatives = (((*D).Op & pkgCache::Dep::Or) == pkgCache::Dep::Or);
1018
1019          if (skipAlternatives == true)
1020          {
1021             /*
1022              * if there are alternatives, we've already picked one, so skip
1023              * the rest
1024              *
1025              * TODO: this means that if there's a build-dep on A|B and B is
1026              * installed, we'll still try to install A; more importantly,
1027              * if A is currently broken, we cannot go back and try B. To fix
1028              * this would require we do a Resolve cycle for each package we
1029              * add to the install list. Ugh
1030              */
1031             if (!hasAlternatives)
1032                skipAlternatives = false; // end of or group
1033             continue;
1034          }
1035
1036          if ((*D).Type == pkgSrcRecords::Parser::BuildConflict ||
1037              (*D).Type == pkgSrcRecords::Parser::BuildConflictIndep)
1038          {
1039             pkgCache::GrpIterator Grp = Cache->FindGrp((*D).Package);
1040             // Build-conflicts on unknown packages are silently ignored
1041             if (Grp.end() == true)
1042                continue;
1043
1044             for (pkgCache::PkgIterator Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))
1045             {
1046                pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
1047                /*
1048                 * Remove if we have an installed version that satisfies the
1049                 * version criteria
1050                 */
1051                if (IV.end() == false &&
1052                    Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
1053                   TryToInstallBuildDep(Pkg,Cache,Fix,true,false);
1054             }
1055          }
1056          else // BuildDep || BuildDepIndep
1057          {
1058             if (_config->FindB("Debug::BuildDeps",false) == true)
1059                  cout << "Looking for " << (*D).Package << "...\n";
1060
1061             pkgCache::PkgIterator Pkg;
1062
1063             // Cross-Building?
1064             if (StripMultiArch == false && D->Type != pkgSrcRecords::Parser::BuildDependIndep)
1065             {
1066                size_t const colon = D->Package.find(":");
1067                if (colon != string::npos)
1068                {
1069                   if (strcmp(D->Package.c_str() + colon, ":any") == 0 || strcmp(D->Package.c_str() + colon, ":native") == 0)
1070                      Pkg = Cache->FindPkg(D->Package.substr(0,colon));
1071                   else
1072                      Pkg = Cache->FindPkg(D->Package);
1073                }
1074                else
1075                   Pkg = Cache->FindPkg(D->Package, hostArch);
1076
1077                // a bad version either is invalid or doesn't satify dependency
1078                #define BADVER(Ver) (Ver.end() == true || \
1079                                     (D->Version.empty() == false && \
1080                                      Cache->VS().CheckDep(Ver.VerStr(),D->Op,D->Version.c_str()) == false))
1081
1082                APT::VersionList verlist;
1083                if (Pkg.end() == false)
1084                {
1085                   pkgCache::VerIterator Ver = (*Cache)[Pkg].InstVerIter(*Cache);
1086                   if (BADVER(Ver) == false)
1087                      verlist.insert(Ver);
1088                   Ver = (*Cache)[Pkg].CandidateVerIter(*Cache);
1089                   if (BADVER(Ver) == false)
1090                      verlist.insert(Ver);
1091                }
1092                if (verlist.empty() == true)
1093                {
1094                   pkgCache::PkgIterator BuildPkg = Cache->FindPkg(D->Package, "native");
1095                   if (BuildPkg.end() == false && Pkg != BuildPkg)
1096                   {
1097                      pkgCache::VerIterator Ver = (*Cache)[BuildPkg].InstVerIter(*Cache);
1098                      if (BADVER(Ver) == false)
1099                         verlist.insert(Ver);
1100                      Ver = (*Cache)[BuildPkg].CandidateVerIter(*Cache);
1101                      if (BADVER(Ver) == false)
1102                         verlist.insert(Ver);
1103                   }
1104                }
1105                #undef BADVER
1106
1107                string forbidden;
1108                // We need to decide if host or build arch, so find a version we can look at
1109                APT::VersionList::const_iterator Ver = verlist.begin();
1110                for (; Ver != verlist.end(); ++Ver)
1111                {
1112                   forbidden.clear();
1113                   if (Ver->MultiArch == pkgCache::Version::None || Ver->MultiArch == pkgCache::Version::All)
1114                   {
1115                      if (colon == string::npos)
1116                         Pkg = Ver.ParentPkg().Group().FindPkg(hostArch);
1117                      else if (strcmp(D->Package.c_str() + colon, ":any") == 0)
1118                         forbidden = "Multi-Arch: none";
1119                      else if (strcmp(D->Package.c_str() + colon, ":native") == 0)
1120                         Pkg = Ver.ParentPkg().Group().FindPkg("native");
1121                   }
1122                   else if (Ver->MultiArch == pkgCache::Version::Same)
1123                   {
1124                      if (colon == string::npos)
1125                         Pkg = Ver.ParentPkg().Group().FindPkg(hostArch);
1126                      else if (strcmp(D->Package.c_str() + colon, ":any") == 0)
1127                         forbidden = "Multi-Arch: same";
1128                      else if (strcmp(D->Package.c_str() + colon, ":native") == 0)
1129                         Pkg = Ver.ParentPkg().Group().FindPkg("native");
1130                   }
1131                   else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
1132                   {
1133                      if (colon == string::npos)
1134                         Pkg = Ver.ParentPkg().Group().FindPkg("native");
1135                      else if (strcmp(D->Package.c_str() + colon, ":any") == 0 ||
1136                               strcmp(D->Package.c_str() + colon, ":native") == 0)
1137                         forbidden = "Multi-Arch: foreign";
1138                   }
1139                   else if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
1140                   {
1141                      if (colon == string::npos)
1142                         Pkg = Ver.ParentPkg().Group().FindPkg(hostArch);
1143                      else if (strcmp(D->Package.c_str() + colon, ":any") == 0)
1144                      {
1145                         // prefer any installed over preferred non-installed architectures
1146                         pkgCache::GrpIterator Grp = Ver.ParentPkg().Group();
1147                         // we don't check for version here as we are better of with upgrading than remove and install
1148                         for (Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))
1149                            if (Pkg.CurrentVer().end() == false)
1150                               break;
1151                         if (Pkg.end() == true)
1152                            Pkg = Grp.FindPreferredPkg(true);
1153                      }
1154                      else if (strcmp(D->Package.c_str() + colon, ":native") == 0)
1155                         Pkg = Ver.ParentPkg().Group().FindPkg("native");
1156                   }
1157
1158                   if (forbidden.empty() == false)
1159                   {
1160                      if (_config->FindB("Debug::BuildDeps",false) == true)
1161                         cout << D->Package.substr(colon, string::npos) << " is not allowed from " << forbidden << " package " << (*D).Package << " (" << Ver.VerStr() << ")" << endl;
1162                      continue;
1163                   }
1164
1165                   //we found a good version
1166                   break;
1167                }
1168                if (Ver == verlist.end())
1169                {
1170                   if (_config->FindB("Debug::BuildDeps",false) == true)
1171                      cout << " No multiarch info as we have no satisfying installed nor candidate for " << D->Package << " on build or host arch" << endl;
1172
1173                   if (forbidden.empty() == false)
1174                   {
1175                      if (hasAlternatives)
1176                         continue;
1177                      return _error->Error(_("%s dependency for %s can't be satisfied "
1178                                             "because %s is not allowed on '%s' packages"),
1179                                           Last->BuildDepType(D->Type), Src.c_str(),
1180                                           D->Package.c_str(), forbidden.c_str());
1181                   }
1182                }
1183             }
1184             else
1185                Pkg = Cache->FindPkg(D->Package);
1186
1187             if (Pkg.end() == true || (Pkg->VersionList == 0 && Pkg->ProvidesList == 0))
1188             {
1189                if (_config->FindB("Debug::BuildDeps",false) == true)
1190                     cout << " (not found)" << (*D).Package << endl;
1191
1192                if (hasAlternatives)
1193                   continue;
1194
1195                return _error->Error(_("%s dependency for %s cannot be satisfied "
1196                                       "because the package %s cannot be found"),
1197                                     Last->BuildDepType((*D).Type),Src.c_str(),
1198                                     (*D).Package.c_str());
1199             }
1200
1201             pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
1202             if (IV.end() == false)
1203             {
1204                if (_config->FindB("Debug::BuildDeps",false) == true)
1205                   cout << "  Is installed\n";
1206
1207                if (D->Version.empty() == true ||
1208                    Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
1209                {
1210                   skipAlternatives = hasAlternatives;
1211                   continue;
1212                }
1213
1214                if (_config->FindB("Debug::BuildDeps",false) == true)
1215                   cout << "    ...but the installed version doesn't meet the version requirement\n";
1216
1217                if (((*D).Op & pkgCache::Dep::LessEq) == pkgCache::Dep::LessEq)
1218                   return _error->Error(_("Failed to satisfy %s dependency for %s: Installed package %s is too new"),
1219                                         Last->BuildDepType((*D).Type), Src.c_str(), Pkg.FullName(true).c_str());
1220             }
1221
1222             // Only consider virtual packages if there is no versioned dependency
1223             if ((*D).Version.empty() == true)
1224             {
1225                /*
1226                 * If this is a virtual package, we need to check the list of
1227                 * packages that provide it and see if any of those are
1228                 * installed
1229                 */
1230                pkgCache::PrvIterator Prv = Pkg.ProvidesList();
1231                for (; Prv.end() != true; ++Prv)
1232                {
1233                   if (_config->FindB("Debug::BuildDeps",false) == true)
1234                      cout << "  Checking provider " << Prv.OwnerPkg().FullName() << endl;
1235
1236                   if ((*Cache)[Prv.OwnerPkg()].InstVerIter(*Cache).end() == false)
1237                      break;
1238                }
1239
1240                if (Prv.end() == false)
1241                {
1242                   if (_config->FindB("Debug::BuildDeps",false) == true)
1243                      cout << "  Is provided by installed package " << Prv.OwnerPkg().FullName() << endl;
1244                   skipAlternatives = hasAlternatives;
1245                   continue;
1246                }
1247             }
1248             else // versioned dependency
1249             {
1250                pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
1251                if (CV.end() == true ||
1252                    Cache->VS().CheckDep(CV.VerStr(),(*D).Op,(*D).Version.c_str()) == false)
1253                {
1254                   if (hasAlternatives)
1255                      continue;
1256                   else if (CV.end() == false)
1257                      return _error->Error(_("%s dependency for %s cannot be satisfied "
1258                                             "because candidate version of package %s "
1259                                             "can't satisfy version requirements"),
1260                                           Last->BuildDepType(D->Type), Src.c_str(),
1261                                           D->Package.c_str());
1262                   else
1263                      return _error->Error(_("%s dependency for %s cannot be satisfied "
1264                                             "because package %s has no candidate version"),
1265                                           Last->BuildDepType(D->Type), Src.c_str(),
1266                                           D->Package.c_str());
1267                }
1268             }
1269
1270             if (TryToInstallBuildDep(Pkg,Cache,Fix,false,false,false) == true)
1271             {
1272                // We successfully installed something; skip remaining alternatives
1273                skipAlternatives = hasAlternatives;
1274                if(_config->FindB("APT::Get::Build-Dep-Automatic", false) == true)
1275                   Cache->MarkAuto(Pkg, true);
1276                continue;
1277             }
1278             else if (hasAlternatives)
1279             {
1280                if (_config->FindB("Debug::BuildDeps",false) == true)
1281                   cout << "  Unsatisfiable, trying alternatives\n";
1282                continue;
1283             }
1284             else
1285             {
1286                return _error->Error(_("Failed to satisfy %s dependency for %s: %s"),
1287                                     Last->BuildDepType((*D).Type),
1288                                     Src.c_str(),
1289                                     (*D).Package.c_str());
1290             }
1291          }
1292       }
1293
1294       if (Fix.Resolve(true) == false)
1295          _error->Discard();
1296
1297       // Now we check the state of the packages,
1298       if (Cache->BrokenCount() != 0)
1299       {
1300          ShowBroken(cout, Cache, false);
1301          return _error->Error(_("Build-dependencies for %s could not be satisfied."),*I);
1302       }
1303    }
1304
1305    if (InstallPackages(Cache, false, true) == false)
1306       return _error->Error(_("Failed to process build dependencies"));
1307    return true;
1308 }
1309                                                                         /*}}}*/
1310 // GetChangelogPath - return a path pointing to a changelog file or dir /*{{{*/
1311 // ---------------------------------------------------------------------
1312 /* This returns a "path" string for the changelog url construction.
1313  * Please note that its not complete, it either needs a "/changelog"
1314  * appended (for the packages.debian.org/changelogs site) or a
1315  * ".changelog" (for third party sites that store the changelog in the
1316  * pool/ next to the deb itself)
1317  * Example return: "pool/main/a/apt/apt_0.8.8ubuntu3"
1318  */
1319 string GetChangelogPath(CacheFile &Cache,
1320                         pkgCache::PkgIterator Pkg,
1321                         pkgCache::VerIterator Ver)
1322 {
1323    string path;
1324
1325    pkgRecords Recs(Cache);
1326    pkgRecords::Parser &rec=Recs.Lookup(Ver.FileList());
1327    string srcpkg = rec.SourcePkg().empty() ? Pkg.Name() : rec.SourcePkg();
1328    string ver = Ver.VerStr();
1329    // if there is a source version it always wins
1330    if (rec.SourceVer() != "")
1331       ver = rec.SourceVer();
1332    path = flNotFile(rec.FileName());
1333    path += srcpkg + "_" + StripEpoch(ver);
1334    return path;
1335 }
1336                                                                         /*}}}*/
1337 // GuessThirdPartyChangelogUri - return url                             /*{{{*/
1338 // ---------------------------------------------------------------------
1339 /* Contruct a changelog file path for third party sites that do not use
1340  * packages.debian.org/changelogs
1341  * This simply uses the ArchiveURI() of the source pkg and looks for
1342  * a .changelog file there, Example for "mediabuntu":
1343  * apt-get changelog mplayer-doc:
1344  *  http://packages.medibuntu.org/pool/non-free/m/mplayer/mplayer_1.0~rc4~try1.dsfg1-1ubuntu1+medibuntu1.changelog
1345  */
1346 bool GuessThirdPartyChangelogUri(CacheFile &Cache,
1347                                  pkgCache::PkgIterator Pkg,
1348                                  pkgCache::VerIterator Ver,
1349                                  string &out_uri)
1350 {
1351    // get the binary deb server path
1352    pkgCache::VerFileIterator Vf = Ver.FileList();
1353    if (Vf.end() == true)
1354       return false;
1355    pkgCache::PkgFileIterator F = Vf.File();
1356    pkgIndexFile *index;
1357    pkgSourceList *SrcList = Cache.GetSourceList();
1358    if(SrcList->FindIndex(F, index) == false)
1359       return false;
1360
1361    // get archive uri for the binary deb
1362    string path_without_dot_changelog = GetChangelogPath(Cache, Pkg, Ver);
1363    out_uri = index->ArchiveURI(path_without_dot_changelog + ".changelog");
1364
1365    // now strip away the filename and add srcpkg_srcver.changelog
1366    return true;
1367 }
1368                                                                         /*}}}*/
1369 // DownloadChangelog - Download the changelog                           /*{{{*/
1370 // ---------------------------------------------------------------------
1371 bool DownloadChangelog(CacheFile &CacheFile, pkgAcquire &Fetcher,
1372                        pkgCache::VerIterator Ver, string targetfile)
1373 /* Download a changelog file for the given package version to
1374  * targetfile. This will first try the server from Apt::Changelogs::Server
1375  * (http://packages.debian.org/changelogs by default) and if that gives
1376  * a 404 tries to get it from the archive directly (see
1377  * GuessThirdPartyChangelogUri for details how)
1378  */
1379 {
1380    string path;
1381    string descr;
1382    string server;
1383    string changelog_uri;
1384
1385    // data structures we need
1386    pkgCache::PkgIterator Pkg = Ver.ParentPkg();
1387
1388    // make the server root configurable
1389    server = _config->Find("Apt::Changelogs::Server",
1390                           "http://packages.debian.org/changelogs");
1391    path = GetChangelogPath(CacheFile, Pkg, Ver);
1392    strprintf(changelog_uri, "%s/%s/changelog", server.c_str(), path.c_str());
1393    if (_config->FindB("APT::Get::Print-URIs", false) == true)
1394    {
1395       std::cout << '\'' << changelog_uri << '\'' << std::endl;
1396       return true;
1397    }
1398
1399    strprintf(descr, _("Changelog for %s (%s)"), Pkg.Name(), changelog_uri.c_str());
1400    // queue it
1401    new pkgAcqFile(&Fetcher, changelog_uri, "", 0, descr, Pkg.Name(), "ignored", targetfile);
1402
1403    // try downloading it, if that fails, try third-party-changelogs location
1404    // FIXME: Fetcher.Run() is "Continue" even if I get a 404?!?
1405    Fetcher.Run();
1406    if (!FileExists(targetfile))
1407    {
1408       string third_party_uri;
1409       if (GuessThirdPartyChangelogUri(CacheFile, Pkg, Ver, third_party_uri))
1410       {
1411          strprintf(descr, _("Changelog for %s (%s)"), Pkg.Name(), third_party_uri.c_str());
1412          new pkgAcqFile(&Fetcher, third_party_uri, "", 0, descr, Pkg.Name(), "ignored", targetfile);
1413          Fetcher.Run();
1414       }
1415    }
1416
1417    if (FileExists(targetfile))
1418       return true;
1419
1420    // error
1421    return _error->Error("changelog download failed");
1422 }
1423                                                                         /*}}}*/
1424 // DoChangelog - Get changelog from the command line                    /*{{{*/
1425 // ---------------------------------------------------------------------
1426 bool DoChangelog(CommandLine &CmdL)
1427 {
1428    CacheFile Cache;
1429    if (Cache.ReadOnlyOpen() == false)
1430       return false;
1431
1432    APT::CacheSetHelper helper(c0out);
1433    APT::VersionList verset = APT::VersionList::FromCommandLine(Cache,
1434                 CmdL.FileList + 1, APT::VersionList::CANDIDATE, helper);
1435    if (verset.empty() == true)
1436       return false;
1437    pkgAcquire Fetcher;
1438
1439    if (_config->FindB("APT::Get::Print-URIs", false) == true)
1440    {
1441       bool Success = true;
1442       for (APT::VersionList::const_iterator Ver = verset.begin();
1443            Ver != verset.end(); ++Ver)
1444          Success &= DownloadChangelog(Cache, Fetcher, Ver, "");
1445       return Success;
1446    }
1447
1448    AcqTextStatus Stat(ScreenWidth, _config->FindI("quiet",0));
1449    Fetcher.Setup(&Stat);
1450
1451    bool const downOnly = _config->FindB("APT::Get::Download-Only", false);
1452
1453    char tmpname[100];
1454    char* tmpdir = NULL;
1455    if (downOnly == false)
1456    {
1457       const char* const tmpDir = getenv("TMPDIR");
1458       if (tmpDir != NULL && *tmpDir != '\0')
1459          snprintf(tmpname, sizeof(tmpname), "%s/apt-changelog-XXXXXX", tmpDir);
1460       else
1461          strncpy(tmpname, "/tmp/apt-changelog-XXXXXX", sizeof(tmpname));
1462       tmpdir = mkdtemp(tmpname);
1463       if (tmpdir == NULL)
1464          return _error->Errno("mkdtemp", "mkdtemp failed");
1465    }
1466
1467    for (APT::VersionList::const_iterator Ver = verset.begin();
1468         Ver != verset.end();
1469         ++Ver)
1470    {
1471       string changelogfile;
1472       if (downOnly == false)
1473          changelogfile.append(tmpname).append("changelog");
1474       else
1475          changelogfile.append(Ver.ParentPkg().Name()).append(".changelog");
1476       if (DownloadChangelog(Cache, Fetcher, Ver, changelogfile) && downOnly == false)
1477       {
1478          DisplayFileInPager(changelogfile);
1479          // cleanup temp file
1480          unlink(changelogfile.c_str());
1481       }
1482    }
1483    // clenaup tmp dir
1484    if (tmpdir != NULL)
1485       rmdir(tmpdir);
1486    return true;
1487 }
1488                                                                         /*}}}*/
1489 // ShowHelp - Show a help screen                                        /*{{{*/
1490 // ---------------------------------------------------------------------
1491 /* */
1492 bool ShowHelp(CommandLine &CmdL)
1493 {
1494    ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,PACKAGE_VERSION,
1495             COMMON_ARCH,__DATE__,__TIME__);
1496
1497    if (_config->FindB("version") == true)
1498    {
1499       cout << _("Supported modules:") << endl;
1500
1501       for (unsigned I = 0; I != pkgVersioningSystem::GlobalListLen; I++)
1502       {
1503          pkgVersioningSystem *VS = pkgVersioningSystem::GlobalList[I];
1504          if (_system != 0 && _system->VS == VS)
1505             cout << '*';
1506          else
1507             cout << ' ';
1508          cout << "Ver: " << VS->Label << endl;
1509
1510          /* Print out all the packaging systems that will work with
1511             this VS */
1512          for (unsigned J = 0; J != pkgSystem::GlobalListLen; J++)
1513          {
1514             pkgSystem *Sys = pkgSystem::GlobalList[J];
1515             if (_system == Sys)
1516                cout << '*';
1517             else
1518                cout << ' ';
1519             if (Sys->VS->TestCompatibility(*VS) == true)
1520                cout << "Pkg:  " << Sys->Label << " (Priority " << Sys->Score(*_config) << ")" << endl;
1521          }
1522       }
1523
1524       for (unsigned I = 0; I != pkgSourceList::Type::GlobalListLen; I++)
1525       {
1526          pkgSourceList::Type *Type = pkgSourceList::Type::GlobalList[I];
1527          cout << " S.L: '" << Type->Name << "' " << Type->Label << endl;
1528       }
1529
1530       for (unsigned I = 0; I != pkgIndexFile::Type::GlobalListLen; I++)
1531       {
1532          pkgIndexFile::Type *Type = pkgIndexFile::Type::GlobalList[I];
1533          cout << " Idx: " << Type->Label << endl;
1534       }
1535
1536       return true;
1537    }
1538
1539    cout <<
1540     _("Usage: apt-get [options] command\n"
1541       "       apt-get [options] install|remove pkg1 [pkg2 ...]\n"
1542       "       apt-get [options] source pkg1 [pkg2 ...]\n"
1543       "\n"
1544       "apt-get is a simple command line interface for downloading and\n"
1545       "installing packages. The most frequently used commands are update\n"
1546       "and install.\n"
1547       "\n"
1548       "Commands:\n"
1549       "   update - Retrieve new lists of packages\n"
1550       "   upgrade - Perform an upgrade\n"
1551       "   install - Install new packages (pkg is libc6 not libc6.deb)\n"
1552       "   remove - Remove packages\n"
1553       "   autoremove - Remove automatically all unused packages\n"
1554       "   purge - Remove packages and config files\n"
1555       "   source - Download source archives\n"
1556       "   build-dep - Configure build-dependencies for source packages\n"
1557       "   dist-upgrade - Distribution upgrade, see apt-get(8)\n"
1558       "   dselect-upgrade - Follow dselect selections\n"
1559       "   clean - Erase downloaded archive files\n"
1560       "   autoclean - Erase old downloaded archive files\n"
1561       "   check - Verify that there are no broken dependencies\n"
1562       "   changelog - Download and display the changelog for the given package\n"
1563       "   download - Download the binary package into the current directory\n"
1564       "\n"
1565       "Options:\n"
1566       "  -h  This help text.\n"
1567       "  -q  Loggable output - no progress indicator\n"
1568       "  -qq No output except for errors\n"
1569       "  -d  Download only - do NOT install or unpack archives\n"
1570       "  -s  No-act. Perform ordering simulation\n"
1571       "  -y  Assume Yes to all queries and do not prompt\n"
1572       "  -f  Attempt to correct a system with broken dependencies in place\n"
1573       "  -m  Attempt to continue if archives are unlocatable\n"
1574       "  -u  Show a list of upgraded packages as well\n"
1575       "  -b  Build the source package after fetching it\n"
1576       "  -V  Show verbose version numbers\n"
1577       "  -c=? Read this configuration file\n"
1578       "  -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
1579       "See the apt-get(8), sources.list(5) and apt.conf(5) manual\n"
1580       "pages for more information and options.\n"
1581       "                       This APT has Super Cow Powers.\n");
1582    return true;
1583 }
1584                                                                         /*}}}*/
1585 // SigWinch - Window size change signal handler                         /*{{{*/
1586 // ---------------------------------------------------------------------
1587 /* */
1588 void SigWinch(int)
1589 {
1590    // Riped from GNU ls
1591 #ifdef TIOCGWINSZ
1592    struct winsize ws;
1593
1594    if (ioctl(1, TIOCGWINSZ, &ws) != -1 && ws.ws_col >= 5)
1595       ScreenWidth = ws.ws_col - 1;
1596 #endif
1597 }
1598                                                                         /*}}}*/
1599 bool DoUpgrade(CommandLine &CmdL)                                       /*{{{*/
1600 {
1601    if (_config->FindB("APT::Get::Upgrade-Allow-New", false) == true)
1602       return DoUpgradeWithAllowNewPackages(CmdL);
1603    else
1604       return DoUpgradeNoNewPackages(CmdL);
1605 }
1606                                                                         /*}}}*/
1607 int main(int argc,const char *argv[])                                   /*{{{*/
1608 {
1609    CommandLine::Dispatch Cmds[] = {{"update",&DoUpdate},
1610                                    {"upgrade",&DoUpgrade},
1611                                    {"install",&DoInstall},
1612                                    {"remove",&DoInstall},
1613                                    {"purge",&DoInstall},
1614                                    {"autoremove",&DoInstall},
1615                                    {"markauto",&DoMarkAuto},
1616                                    {"unmarkauto",&DoMarkAuto},
1617                                    {"dist-upgrade",&DoDistUpgrade},
1618                                    {"dselect-upgrade",&DoDSelectUpgrade},
1619                                    {"build-dep",&DoBuildDep},
1620                                    {"clean",&DoClean},
1621                                    {"autoclean",&DoAutoClean},
1622                                    {"check",&DoCheck},
1623                                    {"source",&DoSource},
1624                                    {"download",&DoDownload},
1625                                    {"changelog",&DoChangelog},
1626                                    {"moo",&DoMoo},
1627                                    {"help",&ShowHelp},
1628                                    {0,0}};
1629
1630    std::vector<CommandLine::Args> Args = getCommandArgs("apt-get", CommandLine::GetCommand(Cmds, argc, argv));
1631
1632    // Set up gettext support
1633    setlocale(LC_ALL,"");
1634    textdomain(PACKAGE);
1635
1636    // Parse the command line and initialize the package library
1637    CommandLine CmdL(Args.data(),_config);
1638    if (pkgInitConfig(*_config) == false ||
1639        CmdL.Parse(argc,argv) == false ||
1640        pkgInitSystem(*_config,_system) == false)
1641    {
1642       if (_config->FindB("version") == true)
1643          ShowHelp(CmdL);
1644
1645       _error->DumpErrors();
1646       return 100;
1647    }
1648
1649    // See if the help should be shown
1650    if (_config->FindB("help") == true ||
1651        _config->FindB("version") == true ||
1652        CmdL.FileSize() == 0)
1653    {
1654       ShowHelp(CmdL);
1655       return 0;
1656    }
1657
1658    // see if we are in simulate mode
1659    CheckSimulateMode(CmdL);
1660
1661    // Deal with stdout not being a tty
1662    if (!isatty(STDOUT_FILENO) && _config->FindI("quiet", -1) == -1)
1663       _config->Set("quiet","1");
1664
1665    // Setup the output streams
1666    InitOutput();
1667
1668    // Setup the signals
1669    signal(SIGPIPE,SIG_IGN);
1670    signal(SIGWINCH,SigWinch);
1671    SigWinch(0);
1672
1673    // Match the operation
1674    CmdL.DispatchArg(Cmds);
1675
1676    // Print any errors or warnings found during parsing
1677    bool const Errors = _error->PendingError();
1678    if (_config->FindI("quiet",0) > 0)
1679       _error->DumpErrors();
1680    else
1681       _error->DumpErrors(GlobalError::DEBUG);
1682    return Errors == true ? 100 : 0;
1683 }
1684                                                                         /*}}}*/