You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

1749 lines
58 KiB

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