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    pkgAcquire Fetcher;
 537    AcqTextStatus Stat(ScreenWidth, _config->FindI("quiet",0));
 538    if (_config->FindB("APT::Get::Print-URIs") == false)
 539       Fetcher.Setup(&Stat);
 540
 541    pkgRecords Recs(Cache);
 542    pkgSourceList *SrcList = Cache.GetSourceList();
 543    bool gotAll = true;
 544
 545    for (APT::VersionList::const_iterator Ver = verset.begin();
 546         Ver != verset.end();
 547         ++Ver)
 548    {
 549       string descr;
 550       // get the right version
 551       pkgCache::PkgIterator Pkg = Ver.ParentPkg();
 552       pkgRecords::Parser &rec=Recs.Lookup(Ver.FileList());
 553       pkgCache::VerFileIterator Vf = Ver.FileList();
 554       if (Vf.end() == true)
 555       {
 556          _error->Error("Can not find VerFile for %s in version %s", Pkg.FullName().c_str(), Ver.VerStr());
 557          gotAll = false;
 558          continue;
 559       }
 560       pkgCache::PkgFileIterator F = Vf.File();
 561       pkgIndexFile *index;
 562       if(SrcList->FindIndex(F, index) == false)
 563       {
 564          _error->Error(_("Can't find a source to download version '%s' of '%s'"), Ver.VerStr(), Pkg.FullName().c_str());
 565          gotAll = false;
 566          continue;
 567       }
 568       string uri = index->ArchiveURI(rec.FileName());
 569       strprintf(descr, _("Downloading %s %s"), Pkg.Name(), Ver.VerStr());
 570       // get the most appropriate hash
 571       HashString hash;
 572       if (rec.SHA512Hash() != "")
 573          hash = HashString("sha512", rec.SHA512Hash());
 574       else if (rec.SHA256Hash() != "")
 575          hash = HashString("sha256", rec.SHA256Hash());
 576       else if (rec.SHA1Hash() != "")
 577          hash = HashString("sha1", rec.SHA1Hash());
 578       else if (rec.MD5Hash() != "")
 579          hash = HashString("md5", rec.MD5Hash());
 580       // get the file
 581       new pkgAcqFile(&Fetcher, uri, hash.toStr(), (*Ver)->Size, descr, Pkg.Name(), ".");
 582    }
 583    if (gotAll == false)
 584       return false;
 585
 586    // Just print out the uris and exit if the --print-uris flag was used
 587    if (_config->FindB("APT::Get::Print-URIs") == true)
 588    {
 589       pkgAcquire::UriIterator I = Fetcher.UriBegin();
 590       for (; I != Fetcher.UriEnd(); ++I)
 591          cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
 592                I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
 593       return true;
 594    }
 595
 596    return (Fetcher.Run() == pkgAcquire::Continue);
 597 }
 598                                                                         /*}}}*/
 599 // DoCheck - Perform the check operation                                /*{{{*/
 600 // ---------------------------------------------------------------------
 601 /* Opening automatically checks the system, this command is mostly used
 602    for debugging */
 603 bool DoCheck(CommandLine &CmdL)
 604 {
 605    CacheFile Cache;
 606    Cache.Open();
 607    Cache.CheckDeps();
 608
 609    return true;
 610 }
 611                                                                         /*}}}*/
 612 // DoSource - Fetch a source archive                                    /*{{{*/
 613 // ---------------------------------------------------------------------
 614 /* Fetch souce packages */
 615 struct DscFile
 616 {
 617    string Package;
 618    string Version;
 619    string Dsc;
 620 };
 621
 622 bool DoSource(CommandLine &CmdL)
 623 {
 624    CacheFile Cache;
 625    if (Cache.Open(false) == false)
 626       return false;
 627
 628    if (CmdL.FileSize() <= 1)
 629       return _error->Error(_("Must specify at least one package to fetch source for"));
 630
 631    // Read the source list
 632    if (Cache.BuildSourceList() == false)
 633       return false;
 634    pkgSourceList *List = Cache.GetSourceList();
 635
 636    // Create the text record parsers
 637    pkgRecords Recs(Cache);
 638    pkgSrcRecords SrcRecs(*List);
 639    if (_error->PendingError() == true)
 640       return false;
 641
 642    // Create the download object
 643    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
 644    pkgAcquire Fetcher;
 645    Fetcher.SetLog(&Stat);
 646
 647    DscFile *Dsc = new DscFile[CmdL.FileSize()];
 648
 649    // insert all downloaded uris into this set to avoid downloading them
 650    // twice
 651    set<string> queued;
 652
 653    // Diff only mode only fetches .diff files
 654    bool const diffOnly = _config->FindB("APT::Get::Diff-Only", false);
 655    // Tar only mode only fetches .tar files
 656    bool const tarOnly = _config->FindB("APT::Get::Tar-Only", false);
 657    // Dsc only mode only fetches .dsc files
 658    bool const dscOnly = _config->FindB("APT::Get::Dsc-Only", false);
 659
 660    // Load the requestd sources into the fetcher
 661    unsigned J = 0;
 662    for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
 663    {
 664       string Src;
 665       pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,*Cache);
 666
 667       if (Last == 0) {
 668          delete[] Dsc;
 669          return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
 670       }
 671
 672       string srec = Last->AsStr();
 673       string::size_type pos = srec.find("\nVcs-");
 674       while (pos != string::npos)
 675       {
 676          pos += strlen("\nVcs-");
 677          string vcs = srec.substr(pos,srec.find(":",pos)-pos);
 678          if(vcs == "Browser")
 679          {
 680             pos = srec.find("\nVcs-", pos);
 681             continue;
 682          }
 683          pos += vcs.length()+2;
 684          string::size_type epos = srec.find("\n", pos);
 685          string uri = srec.substr(pos,epos-pos).c_str();
 686          ioprintf(c1out, _("NOTICE: '%s' packaging is maintained in "
 687                            "the '%s' version control system at:\n"
 688                            "%s\n"),
 689                   Src.c_str(), vcs.c_str(), uri.c_str());
 690          if(vcs == "Bzr")
 691             ioprintf(c1out,_("Please use:\n"
 692                              "bzr branch %s\n"
 693                              "to retrieve the latest (possibly unreleased) "
 694                              "updates to the package.\n"),
 695                      uri.c_str());
 696          break;
 697       }
 698
 699       // Back track
 700       vector<pkgSrcRecords::File> Lst;
 701       if (Last->Files(Lst) == false) {
 702          delete[] Dsc;
 703          return false;
 704       }
 705
 706       // Load them into the fetcher
 707       for (vector<pkgSrcRecords::File>::const_iterator I = Lst.begin();
 708            I != Lst.end(); ++I)
 709       {
 710          // Try to guess what sort of file it is we are getting.
 711          if (I->Type == "dsc")
 712          {
 713             Dsc[J].Package = Last->Package();
 714             Dsc[J].Version = Last->Version();
 715             Dsc[J].Dsc = flNotDir(I->Path);
 716          }
 717
 718          // Handle the only options so that multiple can be used at once
 719          if (diffOnly == true || tarOnly == true || dscOnly == true)
 720          {
 721             if ((diffOnly == true && I->Type == "diff") ||
 722                 (tarOnly == true && I->Type == "tar") ||
 723                 (dscOnly == true && I->Type == "dsc"))
 724                 ; // Fine, we want this file downloaded
 725             else
 726                continue;
 727          }
 728
 729          // don't download the same uri twice (should this be moved to
 730          // the fetcher interface itself?)
 731          if(queued.find(Last->Index().ArchiveURI(I->Path)) != queued.end())
 732             continue;
 733          queued.insert(Last->Index().ArchiveURI(I->Path));
 734
 735          // check if we have a file with that md5 sum already localy
 736          if(!I->MD5Hash.empty() && FileExists(flNotDir(I->Path)))
 737          {
 738             FileFd Fd(flNotDir(I->Path), FileFd::ReadOnly);
 739             MD5Summation sum;
 740             sum.AddFD(Fd.Fd(), Fd.Size());
 741             Fd.Close();
 742             if((string)sum.Result() == I->MD5Hash)
 743             {
 744                ioprintf(c1out,_("Skipping already downloaded file '%s'\n"),
 745                         flNotDir(I->Path).c_str());
 746                continue;
 747             }
 748          }
 749
 750          new pkgAcqFile(&Fetcher,Last->Index().ArchiveURI(I->Path),
 751                         I->MD5Hash,I->Size,
 752                         Last->Index().SourceInfo(*Last,*I),Src);
 753       }
 754    }
 755
 756    // Display statistics
 757    unsigned long long FetchBytes = Fetcher.FetchNeeded();
 758    unsigned long long FetchPBytes = Fetcher.PartialPresent();
 759    unsigned long long DebBytes = Fetcher.TotalNeeded();
 760
 761    // Check for enough free space
 762    struct statvfs Buf;
 763    string OutputDir = ".";
 764    if (statvfs(OutputDir.c_str(),&Buf) != 0) {
 765       delete[] Dsc;
 766       if (errno == EOVERFLOW)
 767          return _error->WarningE("statvfs",_("Couldn't determine free space in %s"),
 768                                 OutputDir.c_str());
 769       else
 770          return _error->Errno("statvfs",_("Couldn't determine free space in %s"),
 771                                 OutputDir.c_str());
 772    } else if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
 773      {
 774        struct statfs Stat;
 775        if (statfs(OutputDir.c_str(),&Stat) != 0
 776 #if HAVE_STRUCT_STATFS_F_TYPE
 777            || unsigned(Stat.f_type) != RAMFS_MAGIC
 778 #endif
 779            )  {
 780          delete[] Dsc;
 781           return _error->Error(_("You don't have enough free space in %s"),
 782               OutputDir.c_str());
 783        }
 784      }
 785
 786    // Number of bytes
 787    if (DebBytes != FetchBytes)
 788       //TRANSLATOR: The required space between number and unit is already included
 789       // in the replacement strings, so %sB will be correctly translate in e.g. 1,5 MB
 790       ioprintf(c1out,_("Need to get %sB/%sB of source archives.\n"),
 791                SizeToStr(FetchBytes).c_str(),SizeToStr(DebBytes).c_str());
 792    else
 793       //TRANSLATOR: The required space between number and unit is already included
 794       // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
 795       ioprintf(c1out,_("Need to get %sB of source archives.\n"),
 796                SizeToStr(DebBytes).c_str());
 797
 798    if (_config->FindB("APT::Get::Simulate",false) == true)
 799    {
 800       for (unsigned I = 0; I != J; I++)
 801          ioprintf(cout,_("Fetch source %s\n"),Dsc[I].Package.c_str());
 802       delete[] Dsc;
 803       return true;
 804    }
 805
 806    // Just print out the uris an exit if the --print-uris flag was used
 807    if (_config->FindB("APT::Get::Print-URIs") == true)
 808    {
 809       pkgAcquire::UriIterator I = Fetcher.UriBegin();
 810       for (; I != Fetcher.UriEnd(); ++I)
 811          cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
 812                I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
 813       delete[] Dsc;
 814       return true;
 815    }
 816
 817    // Run it
 818    bool Failed = false;
 819    if (AcquireRun(Fetcher, 0, &Failed, NULL) == false || Failed == true)
 820    {
 821       delete[] Dsc;
 822       return _error->Error(_("Failed to fetch some archives."));
 823    }
 824
 825    if (_config->FindB("APT::Get::Download-only",false) == true)
 826    {
 827       c1out << _("Download complete and in download only mode") << endl;
 828       delete[] Dsc;
 829       return true;
 830    }
 831
 832    // Unpack the sources
 833    pid_t Process = ExecFork();
 834
 835    if (Process == 0)
 836    {
 837       bool const fixBroken = _config->FindB("APT::Get::Fix-Broken", false);
 838       for (unsigned I = 0; I != J; ++I)
 839       {
 840          string Dir = Dsc[I].Package + '-' + Cache->VS().UpstreamVersion(Dsc[I].Version.c_str());
 841
 842          // Diff only mode only fetches .diff files
 843          if (_config->FindB("APT::Get::Diff-Only",false) == true ||
 844              _config->FindB("APT::Get::Tar-Only",false) == true ||
 845              Dsc[I].Dsc.empty() == true)
 846             continue;
 847
 848          // See if the package is already unpacked
 849          struct stat Stat;
 850          if (fixBroken == false && stat(Dir.c_str(),&Stat) == 0 &&
 851              S_ISDIR(Stat.st_mode) != 0)
 852          {
 853             ioprintf(c0out ,_("Skipping unpack of already unpacked source in %s\n"),
 854                               Dir.c_str());
 855          }
 856          else
 857          {
 858             // Call dpkg-source
 859             char S[500];
 860             snprintf(S,sizeof(S),"%s -x %s",
 861                      _config->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(),
 862                      Dsc[I].Dsc.c_str());
 863             if (system(S) != 0)
 864             {
 865                fprintf(stderr,_("Unpack command '%s' failed.\n"),S);
 866                fprintf(stderr,_("Check if the 'dpkg-dev' package is installed.\n"));
 867                _exit(1);
 868             }
 869          }
 870
 871          // Try to compile it with dpkg-buildpackage
 872          if (_config->FindB("APT::Get::Compile",false) == true)
 873          {
 874             string buildopts = _config->Find("APT::Get::Host-Architecture");
 875             if (buildopts.empty() == false)
 876                buildopts = "-a" + buildopts + " ";
 877             buildopts.append(_config->Find("DPkg::Build-Options","-b -uc"));
 878
 879             // Call dpkg-buildpackage
 880             char S[500];
 881             snprintf(S,sizeof(S),"cd %s && %s %s",
 882                      Dir.c_str(),
 883                      _config->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(),
 884                      buildopts.c_str());
 885
 886             if (system(S) != 0)
 887             {
 888                fprintf(stderr,_("Build command '%s' failed.\n"),S);
 889                _exit(1);
 890             }
 891          }
 892       }
 893
 894       _exit(0);
 895    }
 896    delete[] Dsc;
 897
 898    // Wait for the subprocess
 899    int Status = 0;
 900    while (waitpid(Process,&Status,0) != Process)
 901    {
 902       if (errno == EINTR)
 903          continue;
 904       return _error->Errno("waitpid","Couldn't wait for subprocess");
 905    }
 906
 907    if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
 908       return _error->Error(_("Child process failed"));
 909
 910    return true;
 911 }
 912                                                                         /*}}}*/
 913 // DoBuildDep - Install/removes packages to satisfy build dependencies  /*{{{*/
 914 // ---------------------------------------------------------------------
 915 /* This function will look at the build depends list of the given source
 916    package and install the necessary packages to make it true, or fail. */
 917 bool DoBuildDep(CommandLine &CmdL)
 918 {
 919    CacheFile Cache;
 920
 921    _config->Set("APT::Install-Recommends", false);
 922
 923    if (Cache.Open(true) == false)
 924       return false;
 925
 926    if (CmdL.FileSize() <= 1)
 927       return _error->Error(_("Must specify at least one package to check builddeps for"));
 928
 929    // Read the source list
 930    if (Cache.BuildSourceList() == false)
 931       return false;
 932    pkgSourceList *List = Cache.GetSourceList();
 933
 934    // Create the text record parsers
 935    pkgRecords Recs(Cache);
 936    pkgSrcRecords SrcRecs(*List);
 937    if (_error->PendingError() == true)
 938       return false;
 939
 940    // Create the download object
 941    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
 942    pkgAcquire Fetcher;
 943    if (Fetcher.Setup(&Stat) == false)
 944       return false;
 945
 946    bool StripMultiArch;
 947    string hostArch = _config->Find("APT::Get::Host-Architecture");
 948    if (hostArch.empty() == false)
 949    {
 950       std::vector<std::string> archs = APT::Configuration::getArchitectures();
 951       if (std::find(archs.begin(), archs.end(), hostArch) == archs.end())
 952          return _error->Error(_("No architecture information available for %s. See apt.conf(5) APT::Architectures for setup"), hostArch.c_str());
 953       StripMultiArch = false;
 954    }
 955    else
 956       StripMultiArch = true;
 957
 958    unsigned J = 0;
 959    for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
 960    {
 961       string Src;
 962       pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,*Cache);
 963       if (Last == 0)
 964          return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
 965
 966       // Process the build-dependencies
 967       vector<pkgSrcRecords::Parser::BuildDepRec> BuildDeps;
 968       // FIXME: Can't specify architecture to use for [wildcard] matching, so switch default arch temporary
 969       if (hostArch.empty() == false)
 970       {
 971          std::string nativeArch = _config->Find("APT::Architecture");
 972          _config->Set("APT::Architecture", hostArch);
 973          bool Success = Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only", false), StripMultiArch);
 974          _config->Set("APT::Architecture", nativeArch);
 975          if (Success == false)
 976             return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());
 977       }
 978       else if (Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only", false), StripMultiArch) == false)
 979             return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());
 980
 981       // Also ensure that build-essential packages are present
 982       Configuration::Item const *Opts = _config->Tree("APT::Build-Essential");
 983       if (Opts)
 984          Opts = Opts->Child;
 985       for (; Opts; Opts = Opts->Next)
 986       {
 987          if (Opts->Value.empty() == true)
 988             continue;
 989
 990          pkgSrcRecords::Parser::BuildDepRec rec;
 991          rec.Package = Opts->Value;
 992          rec.Type = pkgSrcRecords::Parser::BuildDependIndep;
 993          rec.Op = 0;
 994          BuildDeps.push_back(rec);
 995       }
 996
 997       if (BuildDeps.empty() == true)
 998       {
 999          ioprintf(c1out,_("%s has no build depends.\n"),Src.c_str());
1000          continue;
1001       }
1002
1003       // Install the requested packages
1004       vector <pkgSrcRecords::Parser::BuildDepRec>::iterator D;
1005       pkgProblemResolver Fix(Cache);
1006       bool skipAlternatives = false; // skip remaining alternatives in an or group
1007       for (D = BuildDeps.begin(); D != BuildDeps.end(); ++D)
1008       {
1009          bool hasAlternatives = (((*D).Op & pkgCache::Dep::Or) == pkgCache::Dep::Or);
1010
1011          if (skipAlternatives == true)
1012          {
1013             /*
1014              * if there are alternatives, we've already picked one, so skip
1015              * the rest
1016              *
1017              * TODO: this means that if there's a build-dep on A|B and B is
1018              * installed, we'll still try to install A; more importantly,
1019              * if A is currently broken, we cannot go back and try B. To fix
1020              * this would require we do a Resolve cycle for each package we
1021              * add to the install list. Ugh
1022              */
1023             if (!hasAlternatives)
1024                skipAlternatives = false; // end of or group
1025             continue;
1026          }
1027
1028          if ((*D).Type == pkgSrcRecords::Parser::BuildConflict ||
1029              (*D).Type == pkgSrcRecords::Parser::BuildConflictIndep)
1030          {
1031             pkgCache::GrpIterator Grp = Cache->FindGrp((*D).Package);
1032             // Build-conflicts on unknown packages are silently ignored
1033             if (Grp.end() == true)
1034                continue;
1035
1036             for (pkgCache::PkgIterator Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))
1037             {
1038                pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
1039                /*
1040                 * Remove if we have an installed version that satisfies the
1041                 * version criteria
1042                 */
1043                if (IV.end() == false &&
1044                    Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
1045                   TryToInstallBuildDep(Pkg,Cache,Fix,true,false);
1046             }
1047          }
1048          else // BuildDep || BuildDepIndep
1049          {
1050             if (_config->FindB("Debug::BuildDeps",false) == true)
1051                  cout << "Looking for " << (*D).Package << "...\n";
1052
1053             pkgCache::PkgIterator Pkg;
1054
1055             // Cross-Building?
1056             if (StripMultiArch == false && D->Type != pkgSrcRecords::Parser::BuildDependIndep)
1057             {
1058                size_t const colon = D->Package.find(":");
1059                if (colon != string::npos)
1060                {
1061                   if (strcmp(D->Package.c_str() + colon, ":any") == 0 || strcmp(D->Package.c_str() + colon, ":native") == 0)
1062                      Pkg = Cache->FindPkg(D->Package.substr(0,colon));
1063                   else
1064                      Pkg = Cache->FindPkg(D->Package);
1065                }
1066                else
1067                   Pkg = Cache->FindPkg(D->Package, hostArch);
1068
1069                // a bad version either is invalid or doesn't satify dependency
1070                #define BADVER(Ver) (Ver.end() == true || \
1071                                     (D->Version.empty() == false && \
1072                                      Cache->VS().CheckDep(Ver.VerStr(),D->Op,D->Version.c_str()) == false))
1073
1074                APT::VersionList verlist;
1075                if (Pkg.end() == false)
1076                {
1077                   pkgCache::VerIterator Ver = (*Cache)[Pkg].InstVerIter(*Cache);
1078                   if (BADVER(Ver) == false)
1079                      verlist.insert(Ver);
1080                   Ver = (*Cache)[Pkg].CandidateVerIter(*Cache);
1081                   if (BADVER(Ver) == false)
1082                      verlist.insert(Ver);
1083                }
1084                if (verlist.empty() == true)
1085                {
1086                   pkgCache::PkgIterator BuildPkg = Cache->FindPkg(D->Package, "native");
1087                   if (BuildPkg.end() == false && Pkg != BuildPkg)
1088                   {
1089                      pkgCache::VerIterator Ver = (*Cache)[BuildPkg].InstVerIter(*Cache);
1090                      if (BADVER(Ver) == false)
1091                         verlist.insert(Ver);
1092                      Ver = (*Cache)[BuildPkg].CandidateVerIter(*Cache);
1093                      if (BADVER(Ver) == false)
1094                         verlist.insert(Ver);
1095                   }
1096                }
1097                #undef BADVER
1098
1099                string forbidden;
1100                // We need to decide if host or build arch, so find a version we can look at
1101                APT::VersionList::const_iterator Ver = verlist.begin();
1102                for (; Ver != verlist.end(); ++Ver)
1103                {
1104                   forbidden.clear();
1105                   if (Ver->MultiArch == pkgCache::Version::None || Ver->MultiArch == pkgCache::Version::All)
1106                   {
1107                      if (colon == string::npos)
1108                         Pkg = Ver.ParentPkg().Group().FindPkg(hostArch);
1109                      else if (strcmp(D->Package.c_str() + colon, ":any") == 0)
1110                         forbidden = "Multi-Arch: none";
1111                      else if (strcmp(D->Package.c_str() + colon, ":native") == 0)
1112                         Pkg = Ver.ParentPkg().Group().FindPkg("native");
1113                   }
1114                   else if (Ver->MultiArch == pkgCache::Version::Same)
1115                   {
1116                      if (colon == string::npos)
1117                         Pkg = Ver.ParentPkg().Group().FindPkg(hostArch);
1118                      else if (strcmp(D->Package.c_str() + colon, ":any") == 0)
1119                         forbidden = "Multi-Arch: same";
1120                      else if (strcmp(D->Package.c_str() + colon, ":native") == 0)
1121                         Pkg = Ver.ParentPkg().Group().FindPkg("native");
1122                   }
1123                   else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
1124                   {
1125                      if (colon == string::npos)
1126                         Pkg = Ver.ParentPkg().Group().FindPkg("native");
1127                      else if (strcmp(D->Package.c_str() + colon, ":any") == 0 ||
1128                               strcmp(D->Package.c_str() + colon, ":native") == 0)
1129                         forbidden = "Multi-Arch: foreign";
1130                   }
1131                   else if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
1132                   {
1133                      if (colon == string::npos)
1134                         Pkg = Ver.ParentPkg().Group().FindPkg(hostArch);
1135                      else if (strcmp(D->Package.c_str() + colon, ":any") == 0)
1136                      {
1137                         // prefer any installed over preferred non-installed architectures
1138                         pkgCache::GrpIterator Grp = Ver.ParentPkg().Group();
1139                         // we don't check for version here as we are better of with upgrading than remove and install
1140                         for (Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))
1141                            if (Pkg.CurrentVer().end() == false)
1142                               break;
1143                         if (Pkg.end() == true)
1144                            Pkg = Grp.FindPreferredPkg(true);
1145                      }
1146                      else if (strcmp(D->Package.c_str() + colon, ":native") == 0)
1147                         Pkg = Ver.ParentPkg().Group().FindPkg("native");
1148                   }
1149
1150                   if (forbidden.empty() == false)
1151                   {
1152                      if (_config->FindB("Debug::BuildDeps",false) == true)
1153                         cout << D->Package.substr(colon, string::npos) << " is not allowed from " << forbidden << " package " << (*D).Package << " (" << Ver.VerStr() << ")" << endl;
1154                      continue;
1155                   }
1156
1157                   //we found a good version
1158                   break;
1159                }
1160                if (Ver == verlist.end())
1161                {
1162                   if (_config->FindB("Debug::BuildDeps",false) == true)
1163                      cout << " No multiarch info as we have no satisfying installed nor candidate for " << D->Package << " on build or host arch" << endl;
1164
1165                   if (forbidden.empty() == false)
1166                   {
1167                      if (hasAlternatives)
1168                         continue;
1169                      return _error->Error(_("%s dependency for %s can't be satisfied "
1170                                             "because %s is not allowed on '%s' packages"),
1171                                           Last->BuildDepType(D->Type), Src.c_str(),
1172                                           D->Package.c_str(), forbidden.c_str());
1173                   }
1174                }
1175             }
1176             else
1177                Pkg = Cache->FindPkg(D->Package);
1178
1179             if (Pkg.end() == true || (Pkg->VersionList == 0 && Pkg->ProvidesList == 0))
1180             {
1181                if (_config->FindB("Debug::BuildDeps",false) == true)
1182                     cout << " (not found)" << (*D).Package << endl;
1183
1184                if (hasAlternatives)
1185                   continue;
1186
1187                return _error->Error(_("%s dependency for %s cannot be satisfied "
1188                                       "because the package %s cannot be found"),
1189                                     Last->BuildDepType((*D).Type),Src.c_str(),
1190                                     (*D).Package.c_str());
1191             }
1192
1193             pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
1194             if (IV.end() == false)
1195             {
1196                if (_config->FindB("Debug::BuildDeps",false) == true)
1197                   cout << "  Is installed\n";
1198
1199                if (D->Version.empty() == true ||
1200                    Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
1201                {
1202                   skipAlternatives = hasAlternatives;
1203                   continue;
1204                }
1205
1206                if (_config->FindB("Debug::BuildDeps",false) == true)
1207                   cout << "    ...but the installed version doesn't meet the version requirement\n";
1208
1209                if (((*D).Op & pkgCache::Dep::LessEq) == pkgCache::Dep::LessEq)
1210                   return _error->Error(_("Failed to satisfy %s dependency for %s: Installed package %s is too new"),
1211                                         Last->BuildDepType((*D).Type), Src.c_str(), Pkg.FullName(true).c_str());
1212             }
1213
1214             // Only consider virtual packages if there is no versioned dependency
1215             if ((*D).Version.empty() == true)
1216             {
1217                /*
1218                 * If this is a virtual package, we need to check the list of
1219                 * packages that provide it and see if any of those are
1220                 * installed
1221                 */
1222                pkgCache::PrvIterator Prv = Pkg.ProvidesList();
1223                for (; Prv.end() != true; ++Prv)
1224                {
1225                   if (_config->FindB("Debug::BuildDeps",false) == true)
1226                      cout << "  Checking provider " << Prv.OwnerPkg().FullName() << endl;
1227
1228                   if ((*Cache)[Prv.OwnerPkg()].InstVerIter(*Cache).end() == false)
1229                      break;
1230                }
1231
1232                if (Prv.end() == false)
1233                {
1234                   if (_config->FindB("Debug::BuildDeps",false) == true)
1235                      cout << "  Is provided by installed package " << Prv.OwnerPkg().FullName() << endl;
1236                   skipAlternatives = hasAlternatives;
1237                   continue;
1238                }
1239             }
1240             else // versioned dependency
1241             {
1242                pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
1243                if (CV.end() == true ||
1244                    Cache->VS().CheckDep(CV.VerStr(),(*D).Op,(*D).Version.c_str()) == false)
1245                {
1246                   if (hasAlternatives)
1247                      continue;
1248                   else if (CV.end() == false)
1249                      return _error->Error(_("%s dependency for %s cannot be satisfied "
1250                                             "because candidate version of package %s "
1251                                             "can't satisfy version requirements"),
1252                                           Last->BuildDepType(D->Type), Src.c_str(),
1253                                           D->Package.c_str());
1254                   else
1255                      return _error->Error(_("%s dependency for %s cannot be satisfied "
1256                                             "because package %s has no candidate version"),
1257                                           Last->BuildDepType(D->Type), Src.c_str(),
1258                                           D->Package.c_str());
1259                }
1260             }
1261
1262             if (TryToInstallBuildDep(Pkg,Cache,Fix,false,false,false) == true)
1263             {
1264                // We successfully installed something; skip remaining alternatives
1265                skipAlternatives = hasAlternatives;
1266                if(_config->FindB("APT::Get::Build-Dep-Automatic", false) == true)
1267                   Cache->MarkAuto(Pkg, true);
1268                continue;
1269             }
1270             else if (hasAlternatives)
1271             {
1272                if (_config->FindB("Debug::BuildDeps",false) == true)
1273                   cout << "  Unsatisfiable, trying alternatives\n";
1274                continue;
1275             }
1276             else
1277             {
1278                return _error->Error(_("Failed to satisfy %s dependency for %s: %s"),
1279                                     Last->BuildDepType((*D).Type),
1280                                     Src.c_str(),
1281                                     (*D).Package.c_str());
1282             }
1283          }
1284       }
1285
1286       if (Fix.Resolve(true) == false)
1287          _error->Discard();
1288
1289       // Now we check the state of the packages,
1290       if (Cache->BrokenCount() != 0)
1291       {
1292          ShowBroken(cout, Cache, false);
1293          return _error->Error(_("Build-dependencies for %s could not be satisfied."),*I);
1294       }
1295    }
1296
1297    if (InstallPackages(Cache, false, true) == false)
1298       return _error->Error(_("Failed to process build dependencies"));
1299    return true;
1300 }
1301                                                                         /*}}}*/
1302 // GetChangelogPath - return a path pointing to a changelog file or dir /*{{{*/
1303 // ---------------------------------------------------------------------
1304 /* This returns a "path" string for the changelog url construction.
1305  * Please note that its not complete, it either needs a "/changelog"
1306  * appended (for the packages.debian.org/changelogs site) or a
1307  * ".changelog" (for third party sites that store the changelog in the
1308  * pool/ next to the deb itself)
1309  * Example return: "pool/main/a/apt/apt_0.8.8ubuntu3"
1310  */
1311 string GetChangelogPath(CacheFile &Cache,
1312                         pkgCache::PkgIterator Pkg,
1313                         pkgCache::VerIterator Ver)
1314 {
1315    string path;
1316
1317    pkgRecords Recs(Cache);
1318    pkgRecords::Parser &rec=Recs.Lookup(Ver.FileList());
1319    string srcpkg = rec.SourcePkg().empty() ? Pkg.Name() : rec.SourcePkg();
1320    string ver = Ver.VerStr();
1321    // if there is a source version it always wins
1322    if (rec.SourceVer() != "")
1323       ver = rec.SourceVer();
1324    path = flNotFile(rec.FileName());
1325    path += srcpkg + "_" + StripEpoch(ver);
1326    return path;
1327 }
1328                                                                         /*}}}*/
1329 // GuessThirdPartyChangelogUri - return url                             /*{{{*/
1330 // ---------------------------------------------------------------------
1331 /* Contruct a changelog file path for third party sites that do not use
1332  * packages.debian.org/changelogs
1333  * This simply uses the ArchiveURI() of the source pkg and looks for
1334  * a .changelog file there, Example for "mediabuntu":
1335  * apt-get changelog mplayer-doc:
1336  *  http://packages.medibuntu.org/pool/non-free/m/mplayer/mplayer_1.0~rc4~try1.dsfg1-1ubuntu1+medibuntu1.changelog
1337  */
1338 bool GuessThirdPartyChangelogUri(CacheFile &Cache,
1339                                  pkgCache::PkgIterator Pkg,
1340                                  pkgCache::VerIterator Ver,
1341                                  string &out_uri)
1342 {
1343    // get the binary deb server path
1344    pkgCache::VerFileIterator Vf = Ver.FileList();
1345    if (Vf.end() == true)
1346       return false;
1347    pkgCache::PkgFileIterator F = Vf.File();
1348    pkgIndexFile *index;
1349    pkgSourceList *SrcList = Cache.GetSourceList();
1350    if(SrcList->FindIndex(F, index) == false)
1351       return false;
1352
1353    // get archive uri for the binary deb
1354    string path_without_dot_changelog = GetChangelogPath(Cache, Pkg, Ver);
1355    out_uri = index->ArchiveURI(path_without_dot_changelog + ".changelog");
1356
1357    // now strip away the filename and add srcpkg_srcver.changelog
1358    return true;
1359 }
1360                                                                         /*}}}*/
1361 // DownloadChangelog - Download the changelog                           /*{{{*/
1362 // ---------------------------------------------------------------------
1363 bool DownloadChangelog(CacheFile &CacheFile, pkgAcquire &Fetcher,
1364                        pkgCache::VerIterator Ver, string targetfile)
1365 /* Download a changelog file for the given package version to
1366  * targetfile. This will first try the server from Apt::Changelogs::Server
1367  * (http://packages.debian.org/changelogs by default) and if that gives
1368  * a 404 tries to get it from the archive directly (see
1369  * GuessThirdPartyChangelogUri for details how)
1370  */
1371 {
1372    string path;
1373    string descr;
1374    string server;
1375    string changelog_uri;
1376
1377    // data structures we need
1378    pkgCache::PkgIterator Pkg = Ver.ParentPkg();
1379
1380    // make the server root configurable
1381    server = _config->Find("Apt::Changelogs::Server",
1382                           "http://packages.debian.org/changelogs");
1383    path = GetChangelogPath(CacheFile, Pkg, Ver);
1384    strprintf(changelog_uri, "%s/%s/changelog", server.c_str(), path.c_str());
1385    if (_config->FindB("APT::Get::Print-URIs", false) == true)
1386    {
1387       std::cout << '\'' << changelog_uri << '\'' << std::endl;
1388       return true;
1389    }
1390
1391    strprintf(descr, _("Changelog for %s (%s)"), Pkg.Name(), changelog_uri.c_str());
1392    // queue it
1393    new pkgAcqFile(&Fetcher, changelog_uri, "", 0, descr, Pkg.Name(), "ignored", targetfile);
1394
1395    // try downloading it, if that fails, try third-party-changelogs location
1396    // FIXME: Fetcher.Run() is "Continue" even if I get a 404?!?
1397    Fetcher.Run();
1398    if (!FileExists(targetfile))
1399    {
1400       string third_party_uri;
1401       if (GuessThirdPartyChangelogUri(CacheFile, Pkg, Ver, third_party_uri))
1402       {
1403          strprintf(descr, _("Changelog for %s (%s)"), Pkg.Name(), third_party_uri.c_str());
1404          new pkgAcqFile(&Fetcher, third_party_uri, "", 0, descr, Pkg.Name(), "ignored", targetfile);
1405          Fetcher.Run();
1406       }
1407    }
1408
1409    if (FileExists(targetfile))
1410       return true;
1411
1412    // error
1413    return _error->Error("changelog download failed");
1414 }
1415                                                                         /*}}}*/
1416 // DisplayFileInPager - Display File with pager                         /*{{{*/
1417 void DisplayFileInPager(string filename)
1418 {
1419    pid_t Process = ExecFork();
1420    if (Process == 0)
1421    {
1422       const char *Args[3];
1423       Args[0] = "/usr/bin/sensible-pager";
1424       Args[1] = filename.c_str();
1425       Args[2] = 0;
1426       execvp(Args[0],(char **)Args);
1427       exit(100);
1428    }
1429
1430    // Wait for the subprocess
1431    ExecWait(Process, "sensible-pager", false);
1432 }
1433                                                                         /*}}}*/
1434 // DoChangelog - Get changelog from the command line                    /*{{{*/
1435 // ---------------------------------------------------------------------
1436 bool DoChangelog(CommandLine &CmdL)
1437 {
1438    CacheFile Cache;
1439    if (Cache.ReadOnlyOpen() == false)
1440       return false;
1441
1442    APT::CacheSetHelper helper(c0out);
1443    APT::VersionList verset = APT::VersionList::FromCommandLine(Cache,
1444                 CmdL.FileList + 1, APT::VersionList::CANDIDATE, helper);
1445    if (verset.empty() == true)
1446       return false;
1447    pkgAcquire Fetcher;
1448
1449    if (_config->FindB("APT::Get::Print-URIs", false) == true)
1450    {
1451       bool Success = true;
1452       for (APT::VersionList::const_iterator Ver = verset.begin();
1453            Ver != verset.end(); ++Ver)
1454          Success &= DownloadChangelog(Cache, Fetcher, Ver, "");
1455       return Success;
1456    }
1457
1458    AcqTextStatus Stat(ScreenWidth, _config->FindI("quiet",0));
1459    Fetcher.Setup(&Stat);
1460
1461    bool const downOnly = _config->FindB("APT::Get::Download-Only", false);
1462
1463    char tmpname[100];
1464    char* tmpdir = NULL;
1465    if (downOnly == false)
1466    {
1467       const char* const tmpDir = getenv("TMPDIR");
1468       if (tmpDir != NULL && *tmpDir != '\0')
1469          snprintf(tmpname, sizeof(tmpname), "%s/apt-changelog-XXXXXX", tmpDir);
1470       else
1471          strncpy(tmpname, "/tmp/apt-changelog-XXXXXX", sizeof(tmpname));
1472       tmpdir = mkdtemp(tmpname);
1473       if (tmpdir == NULL)
1474          return _error->Errno("mkdtemp", "mkdtemp failed");
1475    }
1476
1477    for (APT::VersionList::const_iterator Ver = verset.begin();
1478         Ver != verset.end();
1479         ++Ver)
1480    {
1481       string changelogfile;
1482       if (downOnly == false)
1483          changelogfile.append(tmpname).append("changelog");
1484       else
1485          changelogfile.append(Ver.ParentPkg().Name()).append(".changelog");
1486       if (DownloadChangelog(Cache, Fetcher, Ver, changelogfile) && downOnly == false)
1487       {
1488          DisplayFileInPager(changelogfile);
1489          // cleanup temp file
1490          unlink(changelogfile.c_str());
1491       }
1492    }
1493    // clenaup tmp dir
1494    if (tmpdir != NULL)
1495       rmdir(tmpdir);
1496    return true;
1497 }
1498                                                                         /*}}}*/
1499 // ShowHelp - Show a help screen                                        /*{{{*/
1500 // ---------------------------------------------------------------------
1501 /* */
1502 bool ShowHelp(CommandLine &CmdL)
1503 {
1504    ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,PACKAGE_VERSION,
1505             COMMON_ARCH,__DATE__,__TIME__);
1506
1507    if (_config->FindB("version") == true)
1508    {
1509       cout << _("Supported modules:") << endl;
1510
1511       for (unsigned I = 0; I != pkgVersioningSystem::GlobalListLen; I++)
1512       {
1513          pkgVersioningSystem *VS = pkgVersioningSystem::GlobalList[I];
1514          if (_system != 0 && _system->VS == VS)
1515             cout << '*';
1516          else
1517             cout << ' ';
1518          cout << "Ver: " << VS->Label << endl;
1519
1520          /* Print out all the packaging systems that will work with
1521             this VS */
1522          for (unsigned J = 0; J != pkgSystem::GlobalListLen; J++)
1523          {
1524             pkgSystem *Sys = pkgSystem::GlobalList[J];
1525             if (_system == Sys)
1526                cout << '*';
1527             else
1528                cout << ' ';
1529             if (Sys->VS->TestCompatibility(*VS) == true)
1530                cout << "Pkg:  " << Sys->Label << " (Priority " << Sys->Score(*_config) << ")" << endl;
1531          }
1532       }
1533
1534       for (unsigned I = 0; I != pkgSourceList::Type::GlobalListLen; I++)
1535       {
1536          pkgSourceList::Type *Type = pkgSourceList::Type::GlobalList[I];
1537          cout << " S.L: '" << Type->Name << "' " << Type->Label << endl;
1538       }
1539
1540       for (unsigned I = 0; I != pkgIndexFile::Type::GlobalListLen; I++)
1541       {
1542          pkgIndexFile::Type *Type = pkgIndexFile::Type::GlobalList[I];
1543          cout << " Idx: " << Type->Label << endl;
1544       }
1545
1546       return true;
1547    }
1548
1549    cout <<
1550     _("Usage: apt-get [options] command\n"
1551       "       apt-get [options] install|remove pkg1 [pkg2 ...]\n"
1552       "       apt-get [options] source pkg1 [pkg2 ...]\n"
1553       "\n"
1554       "apt-get is a simple command line interface for downloading and\n"
1555       "installing packages. The most frequently used commands are update\n"
1556       "and install.\n"
1557       "\n"
1558       "Commands:\n"
1559       "   update - Retrieve new lists of packages\n"
1560       "   upgrade - Perform an upgrade\n"
1561       "   install - Install new packages (pkg is libc6 not libc6.deb)\n"
1562       "   remove - Remove packages\n"
1563       "   autoremove - Remove automatically all unused packages\n"
1564       "   purge - Remove packages and config files\n"
1565       "   source - Download source archives\n"
1566       "   build-dep - Configure build-dependencies for source packages\n"
1567       "   dist-upgrade - Distribution upgrade, see apt-get(8)\n"
1568       "   dselect-upgrade - Follow dselect selections\n"
1569       "   clean - Erase downloaded archive files\n"
1570       "   autoclean - Erase old downloaded archive files\n"
1571       "   check - Verify that there are no broken dependencies\n"
1572       "   changelog - Download and display the changelog for the given package\n"
1573       "   download - Download the binary package into the current directory\n"
1574       "\n"
1575       "Options:\n"
1576       "  -h  This help text.\n"
1577       "  -q  Loggable output - no progress indicator\n"
1578       "  -qq No output except for errors\n"
1579       "  -d  Download only - do NOT install or unpack archives\n"
1580       "  -s  No-act. Perform ordering simulation\n"
1581       "  -y  Assume Yes to all queries and do not prompt\n"
1582       "  -f  Attempt to correct a system with broken dependencies in place\n"
1583       "  -m  Attempt to continue if archives are unlocatable\n"
1584       "  -u  Show a list of upgraded packages as well\n"
1585       "  -b  Build the source package after fetching it\n"
1586       "  -V  Show verbose version numbers\n"
1587       "  -c=? Read this configuration file\n"
1588       "  -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
1589       "See the apt-get(8), sources.list(5) and apt.conf(5) manual\n"
1590       "pages for more information and options.\n"
1591       "                       This APT has Super Cow Powers.\n");
1592    return true;
1593 }
1594                                                                         /*}}}*/
1595 // SigWinch - Window size change signal handler                         /*{{{*/
1596 // ---------------------------------------------------------------------
1597 /* */
1598 void SigWinch(int)
1599 {
1600    // Riped from GNU ls
1601 #ifdef TIOCGWINSZ
1602    struct winsize ws;
1603
1604    if (ioctl(1, TIOCGWINSZ, &ws) != -1 && ws.ws_col >= 5)
1605       ScreenWidth = ws.ws_col - 1;
1606 #endif
1607 }
1608                                                                         /*}}}*/
1609 bool DoUpgrade(CommandLine &CmdL)                                       /*{{{*/
1610 {
1611    if (_config->FindB("APT::Get::UpgradeAllowNew", false) == true)
1612       return DoUpgradeWithAllowNewPackages(CmdL);
1613    else
1614       return DoUpgradeNoNewPackages(CmdL);
1615 }
1616                                                                         /*}}}*/
1617 int main(int argc,const char *argv[])                                   /*{{{*/
1618 {
1619    CommandLine::Dispatch Cmds[] = {{"update",&DoUpdate},
1620                                    {"upgrade",&DoUpgrade},
1621                                    {"install",&DoInstall},
1622                                    {"remove",&DoInstall},
1623                                    {"purge",&DoInstall},
1624                                    {"autoremove",&DoInstall},
1625                                    {"markauto",&DoMarkAuto},
1626                                    {"unmarkauto",&DoMarkAuto},
1627                                    {"dist-upgrade",&DoDistUpgrade},
1628                                    {"dselect-upgrade",&DoDSelectUpgrade},
1629                                    {"build-dep",&DoBuildDep},
1630                                    {"clean",&DoClean},
1631                                    {"autoclean",&DoAutoClean},
1632                                    {"check",&DoCheck},
1633                                    {"source",&DoSource},
1634                                    {"download",&DoDownload},
1635                                    {"changelog",&DoChangelog},
1636                                    {"moo",&DoMoo},
1637                                    {"help",&ShowHelp},
1638                                    {0,0}};
1639
1640    std::vector<CommandLine::Args> Args = getCommandArgs("apt-get", CommandLine::GetCommand(Cmds, argc, argv));
1641
1642    // Set up gettext support
1643    setlocale(LC_ALL,"");
1644    textdomain(PACKAGE);
1645
1646    // Parse the command line and initialize the package library
1647    CommandLine CmdL(Args.data(),_config);
1648    if (pkgInitConfig(*_config) == false ||
1649        CmdL.Parse(argc,argv) == false ||
1650        pkgInitSystem(*_config,_system) == false)
1651    {
1652       if (_config->FindB("version") == true)
1653          ShowHelp(CmdL);
1654
1655       _error->DumpErrors();
1656       return 100;
1657    }
1658
1659    // See if the help should be shown
1660    if (_config->FindB("help") == true ||
1661        _config->FindB("version") == true ||
1662        CmdL.FileSize() == 0)
1663    {
1664       ShowHelp(CmdL);
1665       return 0;
1666    }
1667
1668    // see if we are in simulate mode
1669    CheckSimulateMode(CmdL);
1670
1671    // Deal with stdout not being a tty
1672    if (!isatty(STDOUT_FILENO) && _config->FindI("quiet", -1) == -1)
1673       _config->Set("quiet","1");
1674
1675    // Setup the output streams
1676    InitOutput();
1677
1678    // Setup the signals
1679    signal(SIGPIPE,SIG_IGN);
1680    signal(SIGWINCH,SigWinch);
1681    SigWinch(0);
1682
1683    // Match the operation
1684    CmdL.DispatchArg(Cmds);
1685
1686    // Print any errors or warnings found during parsing
1687    bool const Errors = _error->PendingError();
1688    if (_config->FindI("quiet",0) > 0)
1689       _error->DumpErrors();
1690    else
1691       _error->DumpErrors(GlobalError::DEBUG);
1692    return Errors == true ? 100 : 0;
1693 }
1694                                                                         /*}}}*/