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