cmdline/apt-get.cc

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