apt-private/private-source.cc

   1 // Include Files                                                        /*{{{*/
   2 #include <config.h>
   3
   4 #include <apt-pkg/acquire-item.h>
   5 #include <apt-pkg/acquire.h>
   6 #include <apt-pkg/algorithms.h>
   7 #include <apt-pkg/aptconfiguration.h>
   8 #include <apt-pkg/cachefile.h>
   9 #include <apt-pkg/cacheiterators.h>
  10 #include <apt-pkg/cacheset.h>
  11 #include <apt-pkg/cmndline.h>
  12 #include <apt-pkg/configuration.h>
  13 #include <apt-pkg/depcache.h>
  14 #include <apt-pkg/error.h>
  15 #include <apt-pkg/fileutl.h>
  16 #include <apt-pkg/hashes.h>
  17 #include <apt-pkg/indexfile.h>
  18 #include <apt-pkg/metaindex.h>
  19 #include <apt-pkg/pkgcache.h>
  20 #include <apt-pkg/sourcelist.h>
  21 #include <apt-pkg/srcrecords.h>
  22 #include <apt-pkg/strutl.h>
  23 #include <apt-pkg/version.h>
  24 #include <apt-pkg/policy.h>
  25
  26 #include <apt-private/private-cachefile.h>
  27 #include <apt-private/private-cacheset.h>
  28 #include <apt-private/private-download.h>
  29 #include <apt-private/private-install.h>
  30 #include <apt-private/private-source.h>
  31
  32 #include <apt-pkg/debindexfile.h>
  33
  34 #include <stddef.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <sys/stat.h>
  39 #include <unistd.h>
  40
  41 #include <iostream>
  42 #include <sstream>
  43 #include <set>
  44 #include <string>
  45 #include <vector>
  46
  47 #include <apti18n.h>
  48                                                                         /*}}}*/
  49
  50 // GetReleaseFileForSourceRecord - Return Suite for the given srcrecord /*{{{*/
  51 static pkgCache::RlsFileIterator GetReleaseFileForSourceRecord(CacheFile &CacheFile,
  52       pkgSourceList const * const SrcList, pkgSrcRecords::Parser const * const Parse)
  53 {
  54    // try to find release
  55    const pkgIndexFile& CurrentIndexFile = Parse->Index();
  56
  57    for (pkgSourceList::const_iterator S = SrcList->begin();
  58          S != SrcList->end(); ++S)
  59    {
  60       std::vector<pkgIndexFile *> *Indexes = (*S)->GetIndexFiles();
  61       for (std::vector<pkgIndexFile *>::const_iterator IF = Indexes->begin();
  62             IF != Indexes->end(); ++IF)
  63       {
  64          if (&CurrentIndexFile == (*IF))
  65             return (*S)->FindInCache(CacheFile, false);
  66       }
  67    }
  68    return pkgCache::RlsFileIterator(CacheFile);
  69 }
  70                                                                         /*}}}*/
  71 // FindSrc - Find a source record                                       /*{{{*/
  72 static pkgSrcRecords::Parser *FindSrc(const char *Name,
  73                                pkgSrcRecords &SrcRecs,std::string &Src,
  74                                CacheFile &Cache)
  75 {
  76    std::string VerTag, UserRequestedVerTag;
  77    std::string ArchTag = "";
  78    std::string RelTag = _config->Find("APT::Default-Release");
  79    std::string TmpSrc = Name;
  80
  81    // extract release
  82    size_t found = TmpSrc.find_last_of("/");
  83    if (found != std::string::npos)
  84    {
  85       RelTag = TmpSrc.substr(found+1);
  86       TmpSrc = TmpSrc.substr(0,found);
  87    }
  88    // extract the version
  89    found = TmpSrc.find_last_of("=");
  90    if (found != std::string::npos)
  91    {
  92       VerTag = UserRequestedVerTag = TmpSrc.substr(found+1);
  93       TmpSrc = TmpSrc.substr(0,found);
  94    }
  95    // extract arch
  96    found = TmpSrc.find_last_of(":");
  97    if (found != std::string::npos)
  98    {
  99       ArchTag = TmpSrc.substr(found+1);
 100       TmpSrc = TmpSrc.substr(0,found);
 101    }
 102
 103    /* Lookup the version of the package we would install if we were to
 104       install a version and determine the source package name, then look
 105       in the archive for a source package of the same name. */
 106    bool MatchSrcOnly = _config->FindB("APT::Get::Only-Source");
 107    pkgCache::PkgIterator Pkg;
 108    if (ArchTag != "")
 109       Pkg = Cache.GetPkgCache()->FindPkg(TmpSrc, ArchTag);
 110    else
 111       Pkg = Cache.GetPkgCache()->FindPkg(TmpSrc);
 112
 113    // if we can't find a package but the user qualified with a arch,
 114    // error out here
 115    if (Pkg.end() && ArchTag != "")
 116    {
 117       Src = Name;
 118       _error->Error(_("Can not find a package for architecture '%s'"),
 119             ArchTag.c_str());
 120       return 0;
 121    }
 122
 123    if (MatchSrcOnly == false && Pkg.end() == false)
 124    {
 125       if(VerTag != "" || RelTag != "" || ArchTag != "")
 126       {
 127          bool fuzzy = false;
 128          // we have a default release, try to locate the pkg. we do it like
 129          // this because GetCandidateVer() will not "downgrade", that means
 130          // "apt-get source -t stable apt" won't work on a unstable system
 131          for (pkgCache::VerIterator Ver = Pkg.VersionList();; ++Ver)
 132          {
 133             // try first only exact matches, later fuzzy matches
 134             if (Ver.end() == true)
 135             {
 136                if (fuzzy == true)
 137                   break;
 138                fuzzy = true;
 139                Ver = Pkg.VersionList();
 140                // exit right away from the Pkg.VersionList() loop if we
 141                // don't have any versions
 142                if (Ver.end() == true)
 143                   break;
 144             }
 145
 146             // ignore arches that are not for us
 147             if (ArchTag != "" && Ver.Arch() != ArchTag)
 148                continue;
 149
 150             // pick highest version for the arch unless the user wants
 151             // something else
 152             if (ArchTag != "" && VerTag == "" && RelTag == "")
 153                if(Cache.GetPkgCache()->VS->CmpVersion(VerTag, Ver.VerStr()) < 0)
 154                   VerTag = Ver.VerStr();
 155
 156             // We match against a concrete version (or a part of this version)
 157             if (VerTag.empty() == false &&
 158                   (fuzzy == true || Cache.GetPkgCache()->VS->CmpVersion(VerTag, Ver.VerStr()) != 0) && // exact match
 159                   (fuzzy == false || strncmp(VerTag.c_str(), Ver.VerStr(), VerTag.size()) != 0)) // fuzzy match
 160                continue;
 161
 162             for (pkgCache::VerFileIterator VF = Ver.FileList();
 163                   VF.end() == false; ++VF)
 164             {
 165                /* If this is the status file, and the current version is not the
 166                   version in the status file (ie it is not installed, or somesuch)
 167                   then it is not a candidate for installation, ever. This weeds
 168                   out bogus entries that may be due to config-file states, or
 169                   other. */
 170                if ((VF.File()->Flags & pkgCache::Flag::NotSource) ==
 171                      pkgCache::Flag::NotSource && Pkg.CurrentVer() != Ver)
 172                   continue;
 173
 174                // or we match against a release
 175                if(VerTag.empty() == false ||
 176                      (VF.File().Archive() != 0 && VF.File().Archive() == RelTag) ||
 177                      (VF.File().Codename() != 0 && VF.File().Codename() == RelTag))
 178                {
 179                   // the Version we have is possibly fuzzy or includes binUploads,
 180                   // so we use the Version of the SourcePkg (empty if same as package)
 181                   Src = Ver.SourcePkgName();
 182                   VerTag = Ver.SourceVerStr();
 183                   break;
 184                }
 185             }
 186             if (Src.empty() == false)
 187                break;
 188          }
 189       }
 190
 191       if (Src.empty() == true && ArchTag.empty() == false)
 192       {
 193          if (VerTag.empty() == false)
 194             _error->Error(_("Can not find a package '%s' with version '%s'"),
 195                   Pkg.FullName().c_str(), VerTag.c_str());
 196          if (RelTag.empty() == false)
 197             _error->Error(_("Can not find a package '%s' with release '%s'"),
 198                   Pkg.FullName().c_str(), RelTag.c_str());
 199          Src = Name;
 200          return 0;
 201       }
 202
 203
 204       if (Src.empty() == true)
 205       {
 206          // if we don't have found a fitting package yet so we will
 207          // choose a good candidate and proceed with that.
 208          // Maybe we will find a source later on with the right VerTag
 209          // or RelTag
 210          if (Cache.BuildPolicy() == false)
 211             return nullptr;
 212          pkgPolicy * Policy = dynamic_cast<pkgPolicy*>(Cache.GetPolicy());
 213          if (Policy == nullptr)
 214          {
 215             _error->Fatal("Implementation error: dynamic up-casting policy engine failed in FindSrc!");
 216             return nullptr;
 217          }
 218          pkgCache::VerIterator const Ver = Policy->GetCandidateVer(Pkg);
 219          if (Ver.end() == false)
 220          {
 221             if (strcmp(Ver.SourcePkgName(),Ver.ParentPkg().Name()) != 0)
 222                Src = Ver.SourcePkgName();
 223             if (VerTag.empty() == true && strcmp(Ver.SourceVerStr(),Ver.VerStr()) != 0)
 224                VerTag = Ver.SourceVerStr();
 225          }
 226       }
 227    }
 228
 229    if (Src.empty() == true)
 230    {
 231       Src = TmpSrc;
 232    }
 233    else
 234    {
 235       /* if we have a source pkg name, make sure to only search
 236          for srcpkg names, otherwise apt gets confused if there
 237          is a binary package "pkg1" and a source package "pkg1"
 238          with the same name but that comes from different packages */
 239       MatchSrcOnly = true;
 240       if (Src != TmpSrc)
 241       {
 242          ioprintf(c1out, _("Picking '%s' as source package instead of '%s'\n"), Src.c_str(), TmpSrc.c_str());
 243       }
 244    }
 245
 246    // The best hit
 247    pkgSrcRecords::Parser *Last = 0;
 248    unsigned long Offset = 0;
 249    std::string Version;
 250    pkgSourceList const * const SrcList = Cache.GetSourceList();
 251
 252    /* Iterate over all of the hits, which includes the resulting
 253       binary packages in the search */
 254                pkgSrcRecords::Parser *Parse;
 255                while (true)
 256                {
 257                   SrcRecs.Restart();
 258                   while ((Parse = SrcRecs.Find(Src.c_str(), MatchSrcOnly)) != 0)
 259                   {
 260                      const std::string Ver = Parse->Version();
 261
 262                      // See if we need to look for a specific release tag
 263                      if (RelTag.empty() == false && UserRequestedVerTag.empty() == true)
 264                      {
 265                         pkgCache::RlsFileIterator const Rls = GetReleaseFileForSourceRecord(Cache, SrcList, Parse);
 266                         if (Rls.end() == false)
 267                         {
 268                            if ((Rls->Archive != 0 && RelTag != Rls.Archive()) &&
 269                                  (Rls->Codename != 0 && RelTag != Rls.Codename()))
 270                               continue;
 271                         }
 272                      }
 273
 274                      // Ignore all versions which doesn't fit
 275                      if (VerTag.empty() == false &&
 276                            Cache.GetPkgCache()->VS->CmpVersion(VerTag, Ver) != 0) // exact match
 277                         continue;
 278
 279                      // Newer version or an exact match? Save the hit
 280                      if (Last == 0 || Cache.GetPkgCache()->VS->CmpVersion(Version,Ver) < 0) {
 281                         Last = Parse;
 282                         Offset = Parse->Offset();
 283                         Version = Ver;
 284                      }
 285
 286                      // was the version check above an exact match?
 287                      // If so, we don't need to look further
 288                      if (VerTag.empty() == false && (VerTag == Ver))
 289                         break;
 290                   }
 291                   if (UserRequestedVerTag == "" && Version != "" && RelTag != "")
 292                      ioprintf(c1out, "Selected version '%s' (%s) for %s\n",
 293                            Version.c_str(), RelTag.c_str(), Src.c_str());
 294
 295                   if (Last != 0 || VerTag.empty() == true)
 296                      break;
 297                   _error->Error(_("Can not find version '%s' of package '%s'"), VerTag.c_str(), TmpSrc.c_str());
 298                   return 0;
 299                }
 300
 301                if (Last == 0 || Last->Jump(Offset) == false)
 302                   return 0;
 303
 304                return Last;
 305 }
 306                                                                         /*}}}*/
 307 // DoSource - Fetch a source archive                                    /*{{{*/
 308 // ---------------------------------------------------------------------
 309 /* Fetch souce packages */
 310 struct DscFile
 311 {
 312    std::string Package;
 313    std::string Version;
 314    std::string Dsc;
 315 };
 316 bool DoSource(CommandLine &CmdL)
 317 {
 318    if (CmdL.FileSize() <= 1)
 319       return _error->Error(_("Must specify at least one package to fetch source for"));
 320
 321    CacheFile Cache;
 322    if (Cache.BuildCaches(false) == false)
 323       return false;
 324
 325    // Create the text record parsers
 326    pkgSourceList * const List = Cache.GetSourceList();
 327    pkgSrcRecords SrcRecs(*List);
 328    if (_error->PendingError() == true)
 329       return false;
 330
 331    std::unique_ptr<DscFile[]> Dsc(new DscFile[CmdL.FileSize()]);
 332
 333    // insert all downloaded uris into this set to avoid downloading them
 334    // twice
 335    std::set<std::string> queued;
 336
 337    // Diff only mode only fetches .diff files
 338    bool const diffOnly = _config->FindB("APT::Get::Diff-Only", false);
 339    // Tar only mode only fetches .tar files
 340    bool const tarOnly = _config->FindB("APT::Get::Tar-Only", false);
 341    // Dsc only mode only fetches .dsc files
 342    bool const dscOnly = _config->FindB("APT::Get::Dsc-Only", false);
 343
 344    // Load the requestd sources into the fetcher
 345    aptAcquireWithTextStatus Fetcher;
 346    unsigned J = 0;
 347    std::vector<std::string> UntrustedList;
 348    for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
 349    {
 350       std::string Src;
 351       pkgSrcRecords::Parser *Last = FindSrc(*I,SrcRecs,Src,Cache);
 352       if (Last == 0) {
 353          return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
 354       }
 355
 356       if (Last->Index().IsTrusted() == false)
 357          UntrustedList.push_back(Src);
 358
 359       std::string srec = Last->AsStr();
 360       std::string::size_type pos = srec.find("\nVcs-");
 361       while (pos != std::string::npos)
 362       {
 363          pos += strlen("\nVcs-");
 364          std::string vcs = srec.substr(pos,srec.find(":",pos)-pos);
 365          if(vcs == "Browser")
 366          {
 367             pos = srec.find("\nVcs-", pos);
 368             continue;
 369          }
 370          pos += vcs.length()+2;
 371          std::string::size_type epos = srec.find("\n", pos);
 372          std::string const uri = srec.substr(pos,epos-pos);
 373          ioprintf(c1out, _("NOTICE: '%s' packaging is maintained in "
 374                   "the '%s' version control system at:\n"
 375                   "%s\n"),
 376                Src.c_str(), vcs.c_str(), uri.c_str());
 377          std::string vcscmd;
 378          if (vcs == "Bzr")
 379             vcscmd = "bzr branch " + uri;
 380          else if (vcs == "Git")
 381             vcscmd = "git clone " + uri;
 382
 383          if (vcscmd.empty() == false)
 384             ioprintf(c1out,_("Please use:\n%s\n"
 385                      "to retrieve the latest (possibly unreleased) "
 386                      "updates to the package.\n"),
 387                   vcscmd.c_str());
 388          break;
 389       }
 390
 391       // Back track
 392       std::vector<pkgSrcRecords::File2> Lst;
 393       if (Last->Files2(Lst) == false) {
 394          return false;
 395       }
 396
 397       // Load them into the fetcher
 398       for (std::vector<pkgSrcRecords::File2>::const_iterator I = Lst.begin();
 399             I != Lst.end(); ++I)
 400       {
 401          // Try to guess what sort of file it is we are getting.
 402          if (I->Type == "dsc")
 403          {
 404             Dsc[J].Package = Last->Package();
 405             Dsc[J].Version = Last->Version();
 406             Dsc[J].Dsc = flNotDir(I->Path);
 407          }
 408
 409          // Handle the only options so that multiple can be used at once
 410          if (diffOnly == true || tarOnly == true || dscOnly == true)
 411          {
 412             if ((diffOnly == true && I->Type == "diff") ||
 413                   (tarOnly == true && I->Type == "tar") ||
 414                   (dscOnly == true && I->Type == "dsc"))
 415                ; // Fine, we want this file downloaded
 416             else
 417                continue;
 418          }
 419
 420          // don't download the same uri twice (should this be moved to
 421          // the fetcher interface itself?)
 422          if(queued.find(Last->Index().ArchiveURI(I->Path)) != queued.end())
 423             continue;
 424          queued.insert(Last->Index().ArchiveURI(I->Path));
 425
 426          // check if we have a file with that md5 sum already localy
 427          std::string localFile = flNotDir(I->Path);
 428          if (FileExists(localFile) == true)
 429             if(I->Hashes.VerifyFile(localFile) == true)
 430             {
 431                ioprintf(c1out,_("Skipping already downloaded file '%s'\n"),
 432                      localFile.c_str());
 433                continue;
 434             }
 435
 436          // see if we have a hash (Acquire::ForceHash is the only way to have none)
 437          if (I->Hashes.usable() == false && _config->FindB("APT::Get::AllowUnauthenticated",false) == false)
 438          {
 439             ioprintf(c1out, "Skipping download of file '%s' as requested hashsum is not available for authentication\n",
 440                   localFile.c_str());
 441             Dsc[J].Dsc.clear();
 442             continue;
 443          }
 444
 445          new pkgAcqFile(&Fetcher,Last->Index().ArchiveURI(I->Path),
 446                I->Hashes, I->FileSize, Last->Index().SourceInfo(*Last,*I), Src);
 447       }
 448    }
 449
 450    // Display statistics
 451    unsigned long long FetchBytes = Fetcher.FetchNeeded();
 452    unsigned long long FetchPBytes = Fetcher.PartialPresent();
 453    unsigned long long DebBytes = Fetcher.TotalNeeded();
 454
 455    if (CheckFreeSpaceBeforeDownload(".", (FetchBytes - FetchPBytes)) == false)
 456       return false;
 457
 458    // Number of bytes
 459    if (DebBytes != FetchBytes)
 460       //TRANSLATOR: The required space between number and unit is already included
 461       // in the replacement strings, so %sB will be correctly translate in e.g. 1,5 MB
 462       ioprintf(c1out,_("Need to get %sB/%sB of source archives.\n"),
 463             SizeToStr(FetchBytes).c_str(),SizeToStr(DebBytes).c_str());
 464    else
 465       //TRANSLATOR: The required space between number and unit is already included
 466       // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
 467       ioprintf(c1out,_("Need to get %sB of source archives.\n"),
 468             SizeToStr(DebBytes).c_str());
 469
 470    if (_config->FindB("APT::Get::Simulate",false) == true)
 471    {
 472       for (unsigned I = 0; I != J; I++)
 473          ioprintf(std::cout,_("Fetch source %s\n"),Dsc[I].Package.c_str());
 474       return true;
 475    }
 476
 477    // Just print out the uris an exit if the --print-uris flag was used
 478    if (_config->FindB("APT::Get::Print-URIs") == true)
 479    {
 480       pkgAcquire::UriIterator I = Fetcher.UriBegin();
 481       for (; I != Fetcher.UriEnd(); ++I)
 482          std::cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
 483             std::to_string(I->Owner->FileSize) << ' ' << I->Owner->HashSum() << std::endl;
 484       return true;
 485    }
 486
 487    // check authentication status of the source as well
 488    if (UntrustedList.empty() == false && AuthPrompt(UntrustedList, false) == false)
 489       return false;
 490
 491    // Run it
 492    bool Failed = false;
 493    if (AcquireRun(Fetcher, 0, &Failed, NULL) == false || Failed == true)
 494    {
 495       return _error->Error(_("Failed to fetch some archives."));
 496    }
 497
 498    if (diffOnly || tarOnly || dscOnly || _config->FindB("APT::Get::Download-only",false) == true)
 499    {
 500       c1out << _("Download complete and in download only mode") << std::endl;
 501       return true;
 502    }
 503
 504    // Unpack the sources
 505    pid_t Process = ExecFork();
 506
 507    if (Process == 0)
 508    {
 509       bool const fixBroken = _config->FindB("APT::Get::Fix-Broken", false);
 510       for (unsigned I = 0; I != J; ++I)
 511       {
 512          if (unlikely(Dsc[I].Dsc.empty() == true))
 513             continue;
 514          std::string const Dir = Dsc[I].Package + '-' + Cache.GetPkgCache()->VS->UpstreamVersion(Dsc[I].Version.c_str());
 515
 516          // See if the package is already unpacked
 517          struct stat Stat;
 518          if (fixBroken == false && stat(Dir.c_str(),&Stat) == 0 &&
 519                S_ISDIR(Stat.st_mode) != 0)
 520          {
 521             ioprintf(c0out ,_("Skipping unpack of already unpacked source in %s\n"),
 522                   Dir.c_str());
 523          }
 524          else
 525          {
 526             // Call dpkg-source
 527             std::string const sourceopts = _config->Find("DPkg::Source-Options", "-x");
 528             std::string S;
 529             strprintf(S, "%s %s %s",
 530                   _config->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(),
 531                   sourceopts.c_str(), Dsc[I].Dsc.c_str());
 532             if (system(S.c_str()) != 0)
 533             {
 534                fprintf(stderr, _("Unpack command '%s' failed.\n"), S.c_str());
 535                fprintf(stderr, _("Check if the 'dpkg-dev' package is installed.\n"));
 536                _exit(1);
 537             }
 538          }
 539
 540          // Try to compile it with dpkg-buildpackage
 541          if (_config->FindB("APT::Get::Compile",false) == true)
 542          {
 543             std::string buildopts = _config->Find("APT::Get::Host-Architecture");
 544             if (buildopts.empty() == false)
 545                buildopts = "-a" + buildopts + " ";
 546
 547             // get all active build profiles
 548             std::string const profiles = APT::Configuration::getBuildProfilesString();
 549             if (profiles.empty() == false)
 550                buildopts.append(" -P").append(profiles).append(" ");
 551
 552             buildopts.append(_config->Find("DPkg::Build-Options","-b -uc"));
 553
 554             // Call dpkg-buildpackage
 555             std::string S;
 556             strprintf(S, "cd %s && %s %s",
 557                   Dir.c_str(),
 558                   _config->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(),
 559                   buildopts.c_str());
 560
 561             if (system(S.c_str()) != 0)
 562             {
 563                fprintf(stderr, _("Build command '%s' failed.\n"), S.c_str());
 564                _exit(1);
 565             }
 566          }
 567       }
 568
 569       _exit(0);
 570    }
 571
 572    return ExecWait(Process, "dpkg-source");
 573 }
 574                                                                         /*}}}*/
 575 // DoBuildDep - Install/removes packages to satisfy build dependencies  /*{{{*/
 576 // ---------------------------------------------------------------------
 577 /* This function will look at the build depends list of the given source
 578    package and install the necessary packages to make it true, or fail. */
 579 static std::vector<pkgSrcRecords::Parser::BuildDepRec> GetBuildDeps(pkgSrcRecords::Parser * const Last,
 580       char const * const Src, bool const StripMultiArch, std::string const &hostArch)
 581 {
 582    std::vector<pkgSrcRecords::Parser::BuildDepRec> BuildDeps;
 583    // FIXME: Can't specify architecture to use for [wildcard] matching, so switch default arch temporary
 584    if (hostArch.empty() == false)
 585    {
 586       std::string nativeArch = _config->Find("APT::Architecture");
 587       _config->Set("APT::Architecture", hostArch);
 588       bool Success = Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only", false), StripMultiArch);
 589       _config->Set("APT::Architecture", nativeArch);
 590       if (Success == false)
 591       {
 592          _error->Error(_("Unable to get build-dependency information for %s"), Src);
 593          return {};
 594       }
 595    }
 596    else if (Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only", false), StripMultiArch) == false)
 597    {
 598       _error->Error(_("Unable to get build-dependency information for %s"), Src);
 599       return {};
 600    }
 601
 602    if (BuildDeps.empty() == true)
 603       ioprintf(c1out,_("%s has no build depends.\n"), Src);
 604
 605    return BuildDeps;
 606 }
 607 static void WriteBuildDependencyPackage(std::ostringstream &buildDepsPkgFile,
 608       std::string const &PkgName, std::string const &Arch,
 609       std::vector<pkgSrcRecords::Parser::BuildDepRec> const &Dependencies)
 610 {
 611    buildDepsPkgFile << "Package: " << PkgName << "\n"
 612       << "Architecture: " << Arch << "\n"
 613       << "Version: 1\n";
 614
 615    std::string depends, conflicts;
 616    for (auto const &dep: Dependencies)
 617    {
 618       std::string * type;
 619       if (dep.Type == pkgSrcRecords::Parser::BuildConflict ||
 620                   dep.Type == pkgSrcRecords::Parser::BuildConflictIndep ||
 621                   dep.Type == pkgSrcRecords::Parser::BuildConflictArch)
 622          type = &conflicts;
 623       else
 624          type = &depends;
 625
 626       type->append(" ").append(dep.Package);
 627       if (dep.Version.empty() ==  false)
 628          type->append(" (").append(pkgCache::CompTypeDeb(dep.Op)).append(" ").append(dep.Version).append(")");
 629       if ((dep.Op & pkgCache::Dep::Or) == pkgCache::Dep::Or)
 630       {
 631          type->append("\n  |");
 632       }
 633       else
 634          type->append(",\n");
 635    }
 636    if (depends.empty() == false)
 637       buildDepsPkgFile << "Depends:\n" << depends;
 638    if (conflicts.empty() == false)
 639       buildDepsPkgFile << "Conflicts:\n" << conflicts;
 640    buildDepsPkgFile << "\n";
 641 }
 642 bool DoBuildDep(CommandLine &CmdL)
 643 {
 644    CacheFile Cache;
 645    std::vector<std::string> VolatileCmdL;
 646    Cache.GetSourceList()->AddVolatileFiles(CmdL, &VolatileCmdL);
 647
 648    _config->Set("APT::Install-Recommends", false);
 649
 650    if (CmdL.FileSize() <= 1 && VolatileCmdL.empty())
 651       return _error->Error(_("Must specify at least one package to check builddeps for"));
 652
 653    bool StripMultiArch;
 654    std::string hostArch = _config->Find("APT::Get::Host-Architecture");
 655    if (hostArch.empty() == false)
 656    {
 657       std::vector<std::string> archs = APT::Configuration::getArchitectures();
 658       if (std::find(archs.begin(), archs.end(), hostArch) == archs.end())
 659          return _error->Error(_("No architecture information available for %s. See apt.conf(5) APT::Architectures for setup"), hostArch.c_str());
 660       StripMultiArch = false;
 661    }
 662    else
 663       StripMultiArch = true;
 664
 665    std::ostringstream buildDepsPkgFile;
 666    std::vector<std::pair<std::string,std::string>> pseudoPkgs;
 667    // deal with the build essentials first
 668    {
 669       std::vector<pkgSrcRecords::Parser::BuildDepRec> BuildDeps;
 670       Configuration::Item const *Opts = _config->Tree("APT::Build-Essential");
 671       if (Opts)
 672          Opts = Opts->Child;
 673       for (; Opts; Opts = Opts->Next)
 674       {
 675          if (Opts->Value.empty() == true)
 676             continue;
 677
 678          pkgSrcRecords::Parser::BuildDepRec rec;
 679          rec.Package = Opts->Value;
 680          rec.Type = pkgSrcRecords::Parser::BuildDependIndep;
 681          rec.Op = 0;
 682          BuildDeps.push_back(rec);
 683       }
 684       std::string const pseudo = "builddeps:essentials";
 685       std::string const nativeArch = _config->Find("APT::Architecture");
 686       WriteBuildDependencyPackage(buildDepsPkgFile, pseudo, nativeArch, BuildDeps);
 687       pseudoPkgs.emplace_back(pseudo, nativeArch);
 688    }
 689
 690    // Read the source list
 691    if (Cache.BuildSourceList() == false)
 692       return false;
 693    pkgSourceList *List = Cache.GetSourceList();
 694    std::string const pseudoArch = hostArch.empty() ? _config->Find("APT::Architecture") : hostArch;
 695
 696    // FIXME: Avoid volatile sources == cmdline assumption
 697    {
 698       auto const VolatileSources = List->GetVolatileFiles();
 699       if (VolatileSources.size() == VolatileCmdL.size())
 700       {
 701          for (size_t i = 0; i < VolatileSources.size(); ++i)
 702          {
 703             auto const Src = VolatileCmdL[i];
 704             if (DirectoryExists(Src))
 705                ioprintf(c1out, _("Note, using directory '%s' to get the build dependencies\n"), Src.c_str());
 706             else
 707                ioprintf(c1out, _("Note, using file '%s' to get the build dependencies\n"), Src.c_str());
 708             std::unique_ptr<pkgSrcRecords::Parser> Last(VolatileSources[i]->CreateSrcParser());
 709             if (Last == nullptr)
 710                return _error->Error(_("Unable to find a source package for %s"), Src.c_str());
 711
 712             std::string const pseudo = std::string("builddeps:") + Src;
 713             WriteBuildDependencyPackage(buildDepsPkgFile, pseudo, pseudoArch,
 714                   GetBuildDeps(Last.get(), Src.c_str(), StripMultiArch, hostArch));
 715             pseudoPkgs.emplace_back(pseudo, pseudoArch);
 716          }
 717       }
 718       else
 719          return _error->Error("Implementation error: Volatile sources (%lu) and"
 720                "commandline elements (%lu) do not match!", VolatileSources.size(),
 721                VolatileCmdL.size());
 722    }
 723
 724    bool const WantLock = _config->FindB("APT::Get::Print-URIs", false) == false;
 725    if (CmdL.FileList[1] != 0)
 726    {
 727       if (Cache.BuildCaches(WantLock) == false)
 728          return false;
 729       // Create the text record parsers
 730       pkgSrcRecords SrcRecs(*List);
 731       if (_error->PendingError() == true)
 732          return false;
 733       for (const char **I = CmdL.FileList + 1; *I != 0; ++I)
 734       {
 735          std::string Src;
 736          pkgSrcRecords::Parser * const Last = FindSrc(*I,SrcRecs,Src,Cache);
 737          if (Last == nullptr)
 738             return _error->Error(_("Unable to find a source package for %s"), *I);
 739
 740          std::string const pseudo = std::string("builddeps:") + Src;
 741          WriteBuildDependencyPackage(buildDepsPkgFile, pseudo, pseudoArch,
 742                GetBuildDeps(Last, Src.c_str(), StripMultiArch, hostArch));
 743          pseudoPkgs.emplace_back(pseudo, pseudoArch);
 744       }
 745    }
 746
 747    Cache.AddIndexFile(new debStringPackageIndex(buildDepsPkgFile.str()));
 748
 749    if (Cache.Open(WantLock) == false)
 750       return false;
 751    pkgProblemResolver Fix(Cache.GetDepCache());
 752
 753    APT::PackageVector removeAgain;
 754    {
 755       pkgDepCache::ActionGroup group(Cache);
 756       TryToInstall InstallAction(Cache, &Fix, false);
 757       for (auto const &pkg: pseudoPkgs)
 758       {
 759          pkgCache::PkgIterator const Pkg = Cache->FindPkg(pkg.first, pkg.second);
 760          if (Pkg.end())
 761             continue;
 762          Cache->SetCandidateVersion(Pkg.VersionList());
 763          InstallAction(Cache[Pkg].CandidateVerIter(Cache));
 764          removeAgain.push_back(Pkg);
 765       }
 766       InstallAction.doAutoInstall();
 767
 768       OpTextProgress Progress(*_config);
 769       bool const resolver_fail = Fix.Resolve(true, &Progress);
 770       if (resolver_fail == false && Cache->BrokenCount() == 0)
 771          return false;
 772       if (CheckNothingBroken(Cache) == false)
 773          return false;
 774    }
 775    if (DoAutomaticRemove(Cache) == false)
 776       return false;
 777
 778    {
 779       pkgDepCache::ActionGroup group(Cache);
 780       if (_config->FindB("APT::Get::Build-Dep-Automatic", false) == false)
 781       {
 782          for (auto const &pkg: removeAgain)
 783          {
 784             auto const instVer = Cache[pkg].InstVerIter(Cache);
 785             if (unlikely(instVer.end() == true))
 786                continue;
 787             for (auto D = instVer.DependsList(); D.end() != true; ++D)
 788             {
 789                if (D->Type != pkgCache::Dep::Depends || D.IsMultiArchImplicit())
 790                   continue;
 791                APT::VersionList verlist = APT::VersionList::FromDependency(Cache, D, APT::CacheSetHelper::CANDIDATE);
 792                for (auto const &V : verlist)
 793                {
 794                   auto const P = V.ParentPkg();
 795                   if (Cache[P].InstallVer != V)
 796                      continue;
 797                   Cache->MarkAuto(P, false);
 798                }
 799             }
 800          }
 801       }
 802       for (auto const &pkg: removeAgain)
 803          Cache->MarkDelete(pkg, false, 0, true);
 804    }
 805
 806    pseudoPkgs.clear();
 807    if (_error->PendingError() || InstallPackages(Cache, false, true) == false)
 808       return _error->Error(_("Failed to process build dependencies"));
 809    return true;
 810 }
 811                                                                         /*}}}*/