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