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


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