]> git.saurik.com Git - apt.git/blob - cmdline/apt-get.cc
projects / apt.git / blob
? search:


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