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