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