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