1 // -*- mode: cpp; mode: fold -*-
3 // $Id: apt-get.cc,v 1.156 2004/08/28 01:05:16 mdz Exp $
4 /* ######################################################################
6 apt-get - Cover for dpkg
8 This is an allout cover for dpkg implementing a safer front end. It is
9 based largely on libapt-pkg.
11 The syntax is different,
12 apt-get [opt] command [things]
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 - Powerfull upgrader designed to handle the issues with
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
25 ##################################################################### */
27 // Include Files /*{{{*/
28 #define _LARGEFILE_SOURCE
29 #define _LARGEFILE64_SOURCE
31 #include <apt-pkg/aptconfiguration.h>
32 #include <apt-pkg/error.h>
33 #include <apt-pkg/cmndline.h>
34 #include <apt-pkg/init.h>
35 #include <apt-pkg/depcache.h>
36 #include <apt-pkg/sourcelist.h>
37 #include <apt-pkg/algorithms.h>
38 #include <apt-pkg/acquire-item.h>
39 #include <apt-pkg/strutl.h>
40 #include <apt-pkg/clean.h>
41 #include <apt-pkg/srcrecords.h>
42 #include <apt-pkg/version.h>
43 #include <apt-pkg/cachefile.h>
44 #include <apt-pkg/cacheset.h>
45 #include <apt-pkg/sptr.h>
46 #include <apt-pkg/md5.h>
47 #include <apt-pkg/versionmatch.h>
52 #include "acqprogress.h"
59 #include <sys/ioctl.h>
61 #include <sys/statfs.h>
62 #include <sys/statvfs.h>
71 #define statfs statfs64
72 #define statvfs statvfs64
75 #define RAMFS_MAGIC 0x858458f6
82 ofstream
devnull("/dev/null");
83 unsigned int ScreenWidth
= 80 - 1; /* - 1 for the cursor */
85 // class CacheFile - Cover class for some dependency cache functions /*{{{*/
86 // ---------------------------------------------------------------------
88 class CacheFile
: public pkgCacheFile
90 static pkgCache
*SortCache
;
91 static int NameComp(const void *a
,const void *b
);
94 pkgCache::Package
**List
;
97 bool CheckDeps(bool AllowBroken
= false);
98 bool BuildCaches(bool WithLock
= true)
100 OpTextProgress
Prog(*_config
);
101 if (pkgCacheFile::BuildCaches(&Prog
,WithLock
) == false)
105 bool Open(bool WithLock
= true)
107 OpTextProgress
Prog(*_config
);
108 if (pkgCacheFile::Open(&Prog
,WithLock
) == false)
114 bool OpenForInstall()
116 if (_config
->FindB("APT::Get::Print-URIs") == true)
121 CacheFile() : List(0) {};
128 // YnPrompt - Yes No Prompt. /*{{{*/
129 // ---------------------------------------------------------------------
130 /* Returns true on a Yes.*/
131 bool YnPrompt(bool Default
=true)
133 if (_config
->FindB("APT::Get::Assume-Yes",false) == true)
135 c1out
<< _("Y") << endl
;
139 char response
[1024] = "";
140 cin
.getline(response
, sizeof(response
));
145 if (strlen(response
) == 0)
151 Res
= regcomp(&Pattern
, nl_langinfo(YESEXPR
),
152 REG_EXTENDED
|REG_ICASE
|REG_NOSUB
);
156 regerror(Res
,&Pattern
,Error
,sizeof(Error
));
157 return _error
->Error(_("Regex compilation error - %s"),Error
);
160 Res
= regexec(&Pattern
, response
, 0, NULL
, 0);
166 // AnalPrompt - Annoying Yes No Prompt. /*{{{*/
167 // ---------------------------------------------------------------------
168 /* Returns true on a Yes.*/
169 bool AnalPrompt(const char *Text
)
172 cin
.getline(Buf
,sizeof(Buf
));
173 if (strcmp(Buf
,Text
) == 0)
178 // ShowList - Show a list /*{{{*/
179 // ---------------------------------------------------------------------
180 /* This prints out a string of space separated words with a title and
181 a two space indent line wraped to the current screen width. */
182 bool ShowList(ostream
&out
,string Title
,string List
,string VersionsList
)
184 if (List
.empty() == true)
186 // trim trailing space
187 int NonSpace
= List
.find_last_not_of(' ');
190 List
= List
.erase(NonSpace
+ 1);
191 if (List
.empty() == true)
195 // Acount for the leading space
196 int ScreenWidth
= ::ScreenWidth
- 3;
198 out
<< Title
<< endl
;
199 string::size_type Start
= 0;
200 string::size_type VersionsStart
= 0;
201 while (Start
< List
.size())
203 if(_config
->FindB("APT::Get::Show-Versions",false) == true &&
204 VersionsList
.size() > 0) {
205 string::size_type End
;
206 string::size_type VersionsEnd
;
208 End
= List
.find(' ',Start
);
209 VersionsEnd
= VersionsList
.find('\n', VersionsStart
);
211 out
<< " " << string(List
,Start
,End
- Start
) << " (" <<
212 string(VersionsList
,VersionsStart
,VersionsEnd
- VersionsStart
) <<
215 if (End
== string::npos
|| End
< Start
)
216 End
= Start
+ ScreenWidth
;
219 VersionsStart
= VersionsEnd
+ 1;
221 string::size_type End
;
223 if (Start
+ ScreenWidth
>= List
.size())
226 End
= List
.rfind(' ',Start
+ScreenWidth
);
228 if (End
== string::npos
|| End
< Start
)
229 End
= Start
+ ScreenWidth
;
230 out
<< " " << string(List
,Start
,End
- Start
) << endl
;
238 // ShowBroken - Debugging aide /*{{{*/
239 // ---------------------------------------------------------------------
240 /* This prints out the names of all the packages that are broken along
241 with the name of each each broken dependency and a quite version
244 The output looks like:
245 The following packages have unmet dependencies:
246 exim: Depends: libc6 (>= 2.1.94) but 2.1.3-10 is to be installed
247 Depends: libldap2 (>= 2.0.2-2) but it is not going to be installed
248 Depends: libsasl7 but it is not going to be installed
250 void ShowBroken(ostream
&out
,CacheFile
&Cache
,bool Now
)
252 out
<< _("The following packages have unmet dependencies:") << endl
;
253 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
255 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
259 if (Cache
[I
].NowBroken() == false)
264 if (Cache
[I
].InstBroken() == false)
268 // Print out each package and the failed dependencies
269 out
<< " " << I
.FullName(true) << " :";
270 unsigned const Indent
= I
.FullName(true).size() + 3;
272 pkgCache::VerIterator Ver
;
275 Ver
= I
.CurrentVer();
277 Ver
= Cache
[I
].InstVerIter(Cache
);
279 if (Ver
.end() == true)
285 for (pkgCache::DepIterator D
= Ver
.DependsList(); D
.end() == false;)
287 // Compute a single dependency element (glob or)
288 pkgCache::DepIterator Start
;
289 pkgCache::DepIterator End
;
290 D
.GlobOr(Start
,End
); // advances D
292 if (Cache
->IsImportantDep(End
) == false)
297 if ((Cache
[End
] & pkgDepCache::DepGNow
) == pkgDepCache::DepGNow
)
302 if ((Cache
[End
] & pkgDepCache::DepGInstall
) == pkgDepCache::DepGInstall
)
310 for (unsigned J
= 0; J
!= Indent
; J
++)
314 if (FirstOr
== false)
316 for (unsigned J
= 0; J
!= strlen(End
.DepType()) + 3; J
++)
320 out
<< ' ' << End
.DepType() << ": ";
323 out
<< Start
.TargetPkg().FullName(true);
325 // Show a quick summary of the version requirements
326 if (Start
.TargetVer() != 0)
327 out
<< " (" << Start
.CompType() << " " << Start
.TargetVer() << ")";
329 /* Show a summary of the target package if possible. In the case
330 of virtual packages we show nothing */
331 pkgCache::PkgIterator Targ
= Start
.TargetPkg();
332 if (Targ
->ProvidesList
== 0)
335 pkgCache::VerIterator Ver
= Cache
[Targ
].InstVerIter(Cache
);
337 Ver
= Targ
.CurrentVer();
339 if (Ver
.end() == false)
342 ioprintf(out
,_("but %s is installed"),Ver
.VerStr());
344 ioprintf(out
,_("but %s is to be installed"),Ver
.VerStr());
348 if (Cache
[Targ
].CandidateVerIter(Cache
).end() == true)
350 if (Targ
->ProvidesList
== 0)
351 out
<< _("but it is not installable");
353 out
<< _("but it is a virtual package");
356 out
<< (Now
?_("but it is not installed"):_("but it is not going to be installed"));
372 // ShowNew - Show packages to newly install /*{{{*/
373 // ---------------------------------------------------------------------
375 void ShowNew(ostream
&out
,CacheFile
&Cache
)
377 /* Print out a list of packages that are going to be installed extra
378 to what the user asked */
381 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
383 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
384 if (Cache
[I
].NewInstall() == true) {
385 List
+= I
.FullName(true) + " ";
386 VersionsList
+= string(Cache
[I
].CandVersion
) + "\n";
390 ShowList(out
,_("The following NEW packages will be installed:"),List
,VersionsList
);
393 // ShowDel - Show packages to delete /*{{{*/
394 // ---------------------------------------------------------------------
396 void ShowDel(ostream
&out
,CacheFile
&Cache
)
398 /* Print out a list of packages that are going to be removed extra
399 to what the user asked */
402 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
404 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
405 if (Cache
[I
].Delete() == true)
407 if ((Cache
[I
].iFlags
& pkgDepCache::Purge
) == pkgDepCache::Purge
)
408 List
+= I
.FullName(true) + "* ";
410 List
+= I
.FullName(true) + " ";
412 VersionsList
+= string(Cache
[I
].CandVersion
)+ "\n";
416 ShowList(out
,_("The following packages will be REMOVED:"),List
,VersionsList
);
419 // ShowKept - Show kept packages /*{{{*/
420 // ---------------------------------------------------------------------
422 void ShowKept(ostream
&out
,CacheFile
&Cache
)
426 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
428 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
431 if (Cache
[I
].Upgrade() == true || Cache
[I
].Upgradable() == false ||
432 I
->CurrentVer
== 0 || Cache
[I
].Delete() == true)
435 List
+= I
.FullName(true) + " ";
436 VersionsList
+= string(Cache
[I
].CurVersion
) + " => " + Cache
[I
].CandVersion
+ "\n";
438 ShowList(out
,_("The following packages have been kept back:"),List
,VersionsList
);
441 // ShowUpgraded - Show upgraded packages /*{{{*/
442 // ---------------------------------------------------------------------
444 void ShowUpgraded(ostream
&out
,CacheFile
&Cache
)
448 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
450 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
453 if (Cache
[I
].Upgrade() == false || Cache
[I
].NewInstall() == true)
456 List
+= I
.FullName(true) + " ";
457 VersionsList
+= string(Cache
[I
].CurVersion
) + " => " + Cache
[I
].CandVersion
+ "\n";
459 ShowList(out
,_("The following packages will be upgraded:"),List
,VersionsList
);
462 // ShowDowngraded - Show downgraded packages /*{{{*/
463 // ---------------------------------------------------------------------
465 bool ShowDowngraded(ostream
&out
,CacheFile
&Cache
)
469 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
471 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
474 if (Cache
[I
].Downgrade() == false || Cache
[I
].NewInstall() == true)
477 List
+= I
.FullName(true) + " ";
478 VersionsList
+= string(Cache
[I
].CurVersion
) + " => " + Cache
[I
].CandVersion
+ "\n";
480 return ShowList(out
,_("The following packages will be DOWNGRADED:"),List
,VersionsList
);
483 // ShowHold - Show held but changed packages /*{{{*/
484 // ---------------------------------------------------------------------
486 bool ShowHold(ostream
&out
,CacheFile
&Cache
)
490 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
492 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
493 if (Cache
[I
].InstallVer
!= (pkgCache::Version
*)I
.CurrentVer() &&
494 I
->SelectedState
== pkgCache::State::Hold
) {
495 List
+= I
.FullName(true) + " ";
496 VersionsList
+= string(Cache
[I
].CurVersion
) + " => " + Cache
[I
].CandVersion
+ "\n";
500 return ShowList(out
,_("The following held packages will be changed:"),List
,VersionsList
);
503 // ShowEssential - Show an essential package warning /*{{{*/
504 // ---------------------------------------------------------------------
505 /* This prints out a warning message that is not to be ignored. It shows
506 all essential packages and their dependents that are to be removed.
507 It is insanely risky to remove the dependents of an essential package! */
508 bool ShowEssential(ostream
&out
,CacheFile
&Cache
)
512 bool *Added
= new bool[Cache
->Head().PackageCount
];
513 for (unsigned int I
= 0; I
!= Cache
->Head().PackageCount
; I
++)
516 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
518 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
519 if ((I
->Flags
& pkgCache::Flag::Essential
) != pkgCache::Flag::Essential
&&
520 (I
->Flags
& pkgCache::Flag::Important
) != pkgCache::Flag::Important
)
523 // The essential package is being removed
524 if (Cache
[I
].Delete() == true)
526 if (Added
[I
->ID
] == false)
529 List
+= I
.FullName(true) + " ";
530 //VersionsList += string(Cache[I].CurVersion) + "\n"; ???
536 if (I
->CurrentVer
== 0)
539 // Print out any essential package depenendents that are to be removed
540 for (pkgCache::DepIterator D
= I
.CurrentVer().DependsList(); D
.end() == false; D
++)
542 // Skip everything but depends
543 if (D
->Type
!= pkgCache::Dep::PreDepends
&&
544 D
->Type
!= pkgCache::Dep::Depends
)
547 pkgCache::PkgIterator P
= D
.SmartTargetPkg();
548 if (Cache
[P
].Delete() == true)
550 if (Added
[P
->ID
] == true)
555 snprintf(S
,sizeof(S
),_("%s (due to %s) "),P
.FullName(true).c_str(),I
.FullName(true).c_str());
557 //VersionsList += "\n"; ???
563 return ShowList(out
,_("WARNING: The following essential packages will be removed.\n"
564 "This should NOT be done unless you know exactly what you are doing!"),List
,VersionsList
);
568 // Stats - Show some statistics /*{{{*/
569 // ---------------------------------------------------------------------
571 void Stats(ostream
&out
,pkgDepCache
&Dep
)
573 unsigned long Upgrade
= 0;
574 unsigned long Downgrade
= 0;
575 unsigned long Install
= 0;
576 unsigned long ReInstall
= 0;
577 for (pkgCache::PkgIterator I
= Dep
.PkgBegin(); I
.end() == false; I
++)
579 if (Dep
[I
].NewInstall() == true)
583 if (Dep
[I
].Upgrade() == true)
586 if (Dep
[I
].Downgrade() == true)
590 if (Dep
[I
].Delete() == false && (Dep
[I
].iFlags
& pkgDepCache::ReInstall
) == pkgDepCache::ReInstall
)
594 ioprintf(out
,_("%lu upgraded, %lu newly installed, "),
598 ioprintf(out
,_("%lu reinstalled, "),ReInstall
);
600 ioprintf(out
,_("%lu downgraded, "),Downgrade
);
602 ioprintf(out
,_("%lu to remove and %lu not upgraded.\n"),
603 Dep
.DelCount(),Dep
.KeepCount());
605 if (Dep
.BadCount() != 0)
606 ioprintf(out
,_("%lu not fully installed or removed.\n"),
610 // CacheSetHelperAPTGet - responsible for message telling from the CacheSets/*{{{*/
611 class CacheSetHelperAPTGet
: public APT::CacheSetHelper
{
612 /** \brief stream message should be printed to */
614 /** \brief were things like Task or RegEx used to select packages? */
615 bool explicitlyNamed
;
617 APT::PackageSet virtualPkgs
;
620 std::list
<std::pair
<pkgCache::VerIterator
, std::string
> > selectedByRelease
;
622 CacheSetHelperAPTGet(std::ostream
&out
) : APT::CacheSetHelper(true), out(out
) {
623 explicitlyNamed
= true;
626 virtual void showTaskSelection(APT::PackageSet
const &pkgset
, string
const &pattern
) {
627 for (APT::PackageSet::const_iterator Pkg
= pkgset
.begin(); Pkg
!= pkgset
.end(); ++Pkg
)
628 ioprintf(out
, _("Note, selecting '%s' for task '%s'\n"),
629 Pkg
.FullName(true).c_str(), pattern
.c_str());
630 explicitlyNamed
= false;
632 virtual void showRegExSelection(APT::PackageSet
const &pkgset
, string
const &pattern
) {
633 for (APT::PackageSet::const_iterator Pkg
= pkgset
.begin(); Pkg
!= pkgset
.end(); ++Pkg
)
634 ioprintf(out
, _("Note, selecting '%s' for regex '%s'\n"),
635 Pkg
.FullName(true).c_str(), pattern
.c_str());
636 explicitlyNamed
= false;
638 virtual void showSelectedVersion(pkgCache::PkgIterator
const &Pkg
, pkgCache::VerIterator
const Ver
,
639 string
const &ver
, bool const &verIsRel
) {
640 if (ver
== Ver
.VerStr())
642 selectedByRelease
.push_back(make_pair(Ver
, ver
));
645 bool showVirtualPackageErrors(pkgCacheFile
&Cache
) {
646 if (virtualPkgs
.empty() == true)
648 for (APT::PackageSet::const_iterator Pkg
= virtualPkgs
.begin();
649 Pkg
!= virtualPkgs
.end(); ++Pkg
) {
650 if (Pkg
->ProvidesList
!= 0) {
651 ioprintf(c1out
,_("Package %s is a virtual package provided by:\n"),
652 Pkg
.FullName(true).c_str());
654 pkgCache::PrvIterator I
= Pkg
.ProvidesList();
655 unsigned short provider
= 0;
656 for (; I
.end() == false; ++I
) {
657 pkgCache::PkgIterator Pkg
= I
.OwnerPkg();
659 if (Cache
[Pkg
].CandidateVerIter(Cache
) == I
.OwnerVer()) {
660 out
<< " " << Pkg
.FullName(true) << " " << I
.OwnerVer().VerStr();
661 if (Cache
[Pkg
].Install() == true && Cache
[Pkg
].NewInstall() == false)
662 out
<< _(" [Installed]");
667 // if we found no candidate which provide this package, show non-candidates
669 for (I
= Pkg
.ProvidesList(); I
.end() == false; I
++)
670 out
<< " " << I
.OwnerPkg().FullName(true) << " " << I
.OwnerVer().VerStr()
671 << _(" [Not candidate version]") << endl
;
673 out
<< _("You should explicitly select one to install.") << endl
;
676 _("Package %s is not available, but is referred to by another package.\n"
677 "This may mean that the package is missing, has been obsoleted, or\n"
678 "is only available from another source\n"),Pkg
.FullName(true).c_str());
682 SPtrArray
<bool> Seen
= new bool[Cache
.GetPkgCache()->Head().PackageCount
];
683 memset(Seen
,0,Cache
.GetPkgCache()->Head().PackageCount
*sizeof(*Seen
));
684 for (pkgCache::DepIterator Dep
= Pkg
.RevDependsList();
685 Dep
.end() == false; Dep
++) {
686 if (Dep
->Type
!= pkgCache::Dep::Replaces
)
688 if (Seen
[Dep
.ParentPkg()->ID
] == true)
690 Seen
[Dep
.ParentPkg()->ID
] = true;
691 List
+= Dep
.ParentPkg().FullName(true) + " ";
692 //VersionsList += string(Dep.ParentPkg().CurVersion) + "\n"; ???
694 ShowList(out
,_("However the following packages replace it:"),List
,VersionsList
);
701 virtual pkgCache::VerIterator
canNotFindCandidateVer(pkgCacheFile
&Cache
, pkgCache::PkgIterator
const &Pkg
) {
702 APT::VersionSet
const verset
= tryVirtualPackage(Cache
, Pkg
, APT::VersionSet::CANDIDATE
);
703 if (verset
.empty() == false)
704 return *(verset
.begin());
705 if (ShowError
== true) {
706 _error
->Error(_("Package '%s' has no installation candidate"),Pkg
.FullName(true).c_str());
707 virtualPkgs
.insert(Pkg
);
709 return pkgCache::VerIterator(Cache
, 0);
712 virtual pkgCache::VerIterator
canNotFindNewestVer(pkgCacheFile
&Cache
, pkgCache::PkgIterator
const &Pkg
) {
713 APT::VersionSet
const verset
= tryVirtualPackage(Cache
, Pkg
, APT::VersionSet::NEWEST
);
714 if (verset
.empty() == false)
715 return *(verset
.begin());
716 if (ShowError
== true)
717 ioprintf(out
, _("Virtual packages like '%s' can't be removed\n"), Pkg
.FullName(true).c_str());
718 return pkgCache::VerIterator(Cache
, 0);
721 APT::VersionSet
tryVirtualPackage(pkgCacheFile
&Cache
, pkgCache::PkgIterator
const &Pkg
,
722 APT::VersionSet::Version
const &select
) {
723 /* This is a pure virtual package and there is a single available
724 candidate providing it. */
725 if (unlikely(Cache
[Pkg
].CandidateVer
!= 0) || Pkg
->ProvidesList
== 0)
726 return APT::VersionSet();
728 pkgCache::PkgIterator Prov
;
729 bool found_one
= false;
730 for (pkgCache::PrvIterator P
= Pkg
.ProvidesList(); P
; ++P
) {
731 pkgCache::VerIterator
const PVer
= P
.OwnerVer();
732 pkgCache::PkgIterator
const PPkg
= PVer
.ParentPkg();
734 /* Ignore versions that are not a candidate. */
735 if (Cache
[PPkg
].CandidateVer
!= PVer
)
738 if (found_one
== false) {
741 } else if (PPkg
!= Prov
) {
742 found_one
= false; // we found at least two
747 if (found_one
== true) {
748 ioprintf(out
, _("Note, selecting '%s' instead of '%s'\n"),
749 Prov
.FullName(true).c_str(), Pkg
.FullName(true).c_str());
750 return APT::VersionSet::FromPackage(Cache
, Prov
, select
, *this);
752 return APT::VersionSet();
755 inline bool allPkgNamedExplicitly() const { return explicitlyNamed
; }
759 // TryToInstall - Mark a package for installation /*{{{*/
760 struct TryToInstall
{
762 pkgProblemResolver
* Fix
;
764 unsigned long AutoMarkChanged
;
765 APT::PackageSet doAutoInstallLater
;
767 TryToInstall(pkgCacheFile
&Cache
, pkgProblemResolver
*PM
, bool const &FixBroken
) : Cache(&Cache
), Fix(PM
),
768 FixBroken(FixBroken
), AutoMarkChanged(0) {};
770 void operator() (pkgCache::VerIterator
const &Ver
) {
771 pkgCache::PkgIterator Pkg
= Ver
.ParentPkg();
773 Cache
->GetDepCache()->SetCandidateVersion(Ver
);
774 pkgDepCache::StateCache
&State
= (*Cache
)[Pkg
];
776 // Handle the no-upgrade case
777 if (_config
->FindB("APT::Get::upgrade",true) == false && Pkg
->CurrentVer
!= 0)
778 ioprintf(c1out
,_("Skipping %s, it is already installed and upgrade is not set.\n"),
779 Pkg
.FullName(true).c_str());
780 // Ignore request for install if package would be new
781 else if (_config
->FindB("APT::Get::Only-Upgrade", false) == true && Pkg
->CurrentVer
== 0)
782 ioprintf(c1out
,_("Skipping %s, it is not installed and only upgrades are requested.\n"),
783 Pkg
.FullName(true).c_str());
789 Cache
->GetDepCache()->MarkInstall(Pkg
,false);
791 if (State
.Install() == false) {
792 if (_config
->FindB("APT::Get::ReInstall",false) == true) {
793 if (Pkg
->CurrentVer
== 0 || Pkg
.CurrentVer().Downloadable() == false)
794 ioprintf(c1out
,_("Reinstallation of %s is not possible, it cannot be downloaded.\n"),
795 Pkg
.FullName(true).c_str());
797 Cache
->GetDepCache()->SetReInstall(Pkg
, true);
799 ioprintf(c1out
,_("%s is already the newest version.\n"),
800 Pkg
.FullName(true).c_str());
803 // Install it with autoinstalling enabled (if we not respect the minial
804 // required deps or the policy)
805 if (FixBroken
== false)
806 doAutoInstallLater
.insert(Pkg
);
809 // see if we need to fix the auto-mark flag
810 // e.g. apt-get install foo
811 // where foo is marked automatic
812 if (State
.Install() == false &&
813 (State
.Flags
& pkgCache::Flag::Auto
) &&
814 _config
->FindB("APT::Get::ReInstall",false) == false &&
815 _config
->FindB("APT::Get::Only-Upgrade",false) == false &&
816 _config
->FindB("APT::Get::Download-Only",false) == false)
818 ioprintf(c1out
,_("%s set to manually installed.\n"),
819 Pkg
.FullName(true).c_str());
820 Cache
->GetDepCache()->MarkAuto(Pkg
,false);
825 bool propergateReleaseCandiateSwitching(std::list
<std::pair
<pkgCache::VerIterator
, std::string
> > start
, std::ostream
&out
)
827 for (std::list
<std::pair
<pkgCache::VerIterator
, std::string
> >::const_iterator s
= start
.begin();
828 s
!= start
.end(); ++s
)
829 Cache
->GetDepCache()->SetCandidateVersion(s
->first
);
832 std::list
<std::pair
<pkgCache::VerIterator
, pkgCache::VerIterator
> > Changed
;
833 for (std::list
<std::pair
<pkgCache::VerIterator
, std::string
> >::const_iterator s
= start
.begin();
834 s
!= start
.end(); ++s
)
836 Changed
.push_back(std::make_pair(s
->first
, pkgCache::VerIterator(*Cache
)));
837 // We continue here even if it failed to enhance the ShowBroken output
838 Success
&= Cache
->GetDepCache()->SetCandidateRelease(s
->first
, s
->second
, Changed
);
840 for (std::list
<std::pair
<pkgCache::VerIterator
, pkgCache::VerIterator
> >::const_iterator c
= Changed
.begin();
841 c
!= Changed
.end(); ++c
)
843 if (c
->second
.end() == true)
844 ioprintf(out
, _("Selected version '%s' (%s) for '%s'\n"),
845 c
->first
.VerStr(), c
->first
.RelStr().c_str(), c
->first
.ParentPkg().FullName(true).c_str());
846 else if (c
->first
.ParentPkg()->Group
!= c
->second
.ParentPkg()->Group
)
848 pkgCache::VerIterator V
= (*Cache
)[c
->first
.ParentPkg()].CandidateVerIter(*Cache
);
849 ioprintf(out
, _("Selected version '%s' (%s) for '%s' because of '%s'\n"), V
.VerStr(),
850 V
.RelStr().c_str(), V
.ParentPkg().FullName(true).c_str(), c
->second
.ParentPkg().FullName(true).c_str());
856 void doAutoInstall() {
857 for (APT::PackageSet::const_iterator P
= doAutoInstallLater
.begin();
858 P
!= doAutoInstallLater
.end(); ++P
) {
859 pkgDepCache::StateCache
&State
= (*Cache
)[P
];
860 if (State
.InstBroken() == false && State
.InstPolicyBroken() == false)
862 Cache
->GetDepCache()->MarkInstall(P
, true);
864 doAutoInstallLater
.clear();
868 // TryToRemove - Mark a package for removal /*{{{*/
871 pkgProblemResolver
* Fix
;
874 unsigned long AutoMarkChanged
;
876 TryToRemove(pkgCacheFile
&Cache
, pkgProblemResolver
*PM
) : Cache(&Cache
), Fix(PM
),
877 PurgePkgs(_config
->FindB("APT::Get::Purge", false)) {};
879 void operator() (pkgCache::VerIterator
const &Ver
)
881 pkgCache::PkgIterator Pkg
= Ver
.ParentPkg();
890 if ((Pkg
->CurrentVer
== 0 && PurgePkgs
== false) ||
891 (PurgePkgs
== true && Pkg
->CurrentState
== pkgCache::State::NotInstalled
))
893 ioprintf(c1out
,_("Package %s is not installed, so not removed\n"),Pkg
.FullName(true).c_str());
894 // MarkInstall refuses to install packages on hold
895 Pkg
->SelectedState
= pkgCache::State::Hold
;
898 Cache
->GetDepCache()->MarkDelete(Pkg
, PurgePkgs
);
902 // CacheFile::NameComp - QSort compare by name /*{{{*/
903 // ---------------------------------------------------------------------
905 pkgCache
*CacheFile::SortCache
= 0;
906 int CacheFile::NameComp(const void *a
,const void *b
)
908 if (*(pkgCache::Package
**)a
== 0 || *(pkgCache::Package
**)b
== 0)
909 return *(pkgCache::Package
**)a
- *(pkgCache::Package
**)b
;
911 const pkgCache::Package
&A
= **(pkgCache::Package
**)a
;
912 const pkgCache::Package
&B
= **(pkgCache::Package
**)b
;
914 return strcmp(SortCache
->StrP
+ A
.Name
,SortCache
->StrP
+ B
.Name
);
917 // CacheFile::Sort - Sort by name /*{{{*/
918 // ---------------------------------------------------------------------
920 void CacheFile::Sort()
923 List
= new pkgCache::Package
*[Cache
->Head().PackageCount
];
924 memset(List
,0,sizeof(*List
)*Cache
->Head().PackageCount
);
925 pkgCache::PkgIterator I
= Cache
->PkgBegin();
926 for (;I
.end() != true; I
++)
930 qsort(List
,Cache
->Head().PackageCount
,sizeof(*List
),NameComp
);
933 // CacheFile::CheckDeps - Open the cache file /*{{{*/
934 // ---------------------------------------------------------------------
935 /* This routine generates the caches and then opens the dependency cache
936 and verifies that the system is OK. */
937 bool CacheFile::CheckDeps(bool AllowBroken
)
939 bool FixBroken
= _config
->FindB("APT::Get::Fix-Broken",false);
941 if (_error
->PendingError() == true)
944 // Check that the system is OK
945 if (DCache
->DelCount() != 0 || DCache
->InstCount() != 0)
946 return _error
->Error("Internal error, non-zero counts");
948 // Apply corrections for half-installed packages
949 if (pkgApplyStatus(*DCache
) == false)
952 if (_config
->FindB("APT::Get::Fix-Policy-Broken",false) == true)
955 if ((DCache
->PolicyBrokenCount() > 0))
957 // upgrade all policy-broken packages with ForceImportantDeps=True
958 for (pkgCache::PkgIterator I
= Cache
->PkgBegin(); !I
.end(); I
++)
959 if ((*DCache
)[I
].NowPolicyBroken() == true)
960 DCache
->MarkInstall(I
,true,0, false, true);
965 if (DCache
->BrokenCount() == 0 || AllowBroken
== true)
968 // Attempt to fix broken things
969 if (FixBroken
== true)
971 c1out
<< _("Correcting dependencies...") << flush
;
972 if (pkgFixBroken(*DCache
) == false || DCache
->BrokenCount() != 0)
974 c1out
<< _(" failed.") << endl
;
975 ShowBroken(c1out
,*this,true);
977 return _error
->Error(_("Unable to correct dependencies"));
979 if (pkgMinimizeUpgrade(*DCache
) == false)
980 return _error
->Error(_("Unable to minimize the upgrade set"));
982 c1out
<< _(" Done") << endl
;
986 c1out
<< _("You might want to run 'apt-get -f install' to correct these.") << endl
;
987 ShowBroken(c1out
,*this,true);
989 return _error
->Error(_("Unmet dependencies. Try using -f."));
995 // CheckAuth - check if each download comes form a trusted source /*{{{*/
996 // ---------------------------------------------------------------------
998 static bool CheckAuth(pkgAcquire
& Fetcher
)
1000 string UntrustedList
;
1001 for (pkgAcquire::ItemIterator I
= Fetcher
.ItemsBegin(); I
< Fetcher
.ItemsEnd(); ++I
)
1003 if (!(*I
)->IsTrusted())
1005 UntrustedList
+= string((*I
)->ShortDesc()) + " ";
1009 if (UntrustedList
== "")
1014 ShowList(c2out
,_("WARNING: The following packages cannot be authenticated!"),UntrustedList
,"");
1016 if (_config
->FindB("APT::Get::AllowUnauthenticated",false) == true)
1018 c2out
<< _("Authentication warning overridden.\n");
1022 if (_config
->FindI("quiet",0) < 2
1023 && _config
->FindB("APT::Get::Assume-Yes",false) == false)
1025 c2out
<< _("Install these packages without verification [y/N]? ") << flush
;
1026 if (!YnPrompt(false))
1027 return _error
->Error(_("Some packages could not be authenticated"));
1031 else if (_config
->FindB("APT::Get::Force-Yes",false) == true)
1036 return _error
->Error(_("There are problems and -y was used without --force-yes"));
1039 // InstallPackages - Actually download and install the packages /*{{{*/
1040 // ---------------------------------------------------------------------
1041 /* This displays the informative messages describing what is going to
1042 happen and then calls the download routines */
1043 bool InstallPackages(CacheFile
&Cache
,bool ShwKept
,bool Ask
= true,
1046 if (_config
->FindB("APT::Get::Purge",false) == true)
1048 pkgCache::PkgIterator I
= Cache
->PkgBegin();
1049 for (; I
.end() == false; I
++)
1051 if (I
.Purge() == false && Cache
[I
].Mode
== pkgDepCache::ModeDelete
)
1052 Cache
->MarkDelete(I
,true);
1057 bool Essential
= false;
1059 // Show all the various warning indicators
1060 ShowDel(c1out
,Cache
);
1061 ShowNew(c1out
,Cache
);
1062 if (ShwKept
== true)
1063 ShowKept(c1out
,Cache
);
1064 Fail
|= !ShowHold(c1out
,Cache
);
1065 if (_config
->FindB("APT::Get::Show-Upgraded",true) == true)
1066 ShowUpgraded(c1out
,Cache
);
1067 Fail
|= !ShowDowngraded(c1out
,Cache
);
1068 if (_config
->FindB("APT::Get::Download-Only",false) == false)
1069 Essential
= !ShowEssential(c1out
,Cache
);
1074 if (Cache
->BrokenCount() != 0)
1076 ShowBroken(c1out
,Cache
,false);
1077 return _error
->Error(_("Internal error, InstallPackages was called with broken packages!"));
1080 if (Cache
->DelCount() == 0 && Cache
->InstCount() == 0 &&
1081 Cache
->BadCount() == 0)
1085 if (Cache
->DelCount() != 0 && _config
->FindB("APT::Get::Remove",true) == false)
1086 return _error
->Error(_("Packages need to be removed but remove is disabled."));
1088 // Run the simulator ..
1089 if (_config
->FindB("APT::Get::Simulate") == true)
1091 pkgSimulate
PM(Cache
);
1092 int status_fd
= _config
->FindI("APT::Status-Fd",-1);
1093 pkgPackageManager::OrderResult Res
= PM
.DoInstall(status_fd
);
1094 if (Res
== pkgPackageManager::Failed
)
1096 if (Res
!= pkgPackageManager::Completed
)
1097 return _error
->Error(_("Internal error, Ordering didn't finish"));
1101 // Create the text record parser
1102 pkgRecords
Recs(Cache
);
1103 if (_error
->PendingError() == true)
1106 // Create the download object
1108 AcqTextStatus
Stat(ScreenWidth
,_config
->FindI("quiet",0));
1109 if (_config
->FindB("APT::Get::Print-URIs", false) == true)
1111 // force a hashsum for compatibility reasons
1112 _config
->CndSet("Acquire::ForceHash", "md5sum");
1114 else if (Fetcher
.Setup(&Stat
, _config
->FindDir("Dir::Cache::Archives")) == false)
1117 // Read the source list
1118 if (Cache
.BuildSourceList() == false)
1120 pkgSourceList
*List
= Cache
.GetSourceList();
1122 // Create the package manager and prepare to download
1123 SPtr
<pkgPackageManager
> PM
= _system
->CreatePM(Cache
);
1124 if (PM
->GetArchives(&Fetcher
,List
,&Recs
) == false ||
1125 _error
->PendingError() == true)
1128 // Display statistics
1129 unsigned long long FetchBytes
= Fetcher
.FetchNeeded();
1130 unsigned long long FetchPBytes
= Fetcher
.PartialPresent();
1131 unsigned long long DebBytes
= Fetcher
.TotalNeeded();
1132 if (DebBytes
!= Cache
->DebSize())
1134 c0out
<< DebBytes
<< ',' << Cache
->DebSize() << endl
;
1135 c0out
<< _("How odd.. The sizes didn't match, email apt@packages.debian.org") << endl
;
1139 if (DebBytes
!= FetchBytes
)
1140 //TRANSLATOR: The required space between number and unit is already included
1141 // in the replacement strings, so %sB will be correctly translate in e.g. 1,5 MB
1142 ioprintf(c1out
,_("Need to get %sB/%sB of archives.\n"),
1143 SizeToStr(FetchBytes
).c_str(),SizeToStr(DebBytes
).c_str());
1144 else if (DebBytes
!= 0)
1145 //TRANSLATOR: The required space between number and unit is already included
1146 // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
1147 ioprintf(c1out
,_("Need to get %sB of archives.\n"),
1148 SizeToStr(DebBytes
).c_str());
1151 if (Cache
->UsrSize() >= 0)
1152 //TRANSLATOR: The required space between number and unit is already included
1153 // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
1154 ioprintf(c1out
,_("After this operation, %sB of additional disk space will be used.\n"),
1155 SizeToStr(Cache
->UsrSize()).c_str());
1157 //TRANSLATOR: The required space between number and unit is already included
1158 // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
1159 ioprintf(c1out
,_("After this operation, %sB disk space will be freed.\n"),
1160 SizeToStr(-1*Cache
->UsrSize()).c_str());
1162 if (_error
->PendingError() == true)
1165 /* Check for enough free space, but only if we are actually going to
1167 if (_config
->FindB("APT::Get::Print-URIs") == false &&
1168 _config
->FindB("APT::Get::Download",true) == true)
1171 string OutputDir
= _config
->FindDir("Dir::Cache::Archives");
1172 if (statvfs(OutputDir
.c_str(),&Buf
) != 0) {
1173 if (errno
== EOVERFLOW
)
1174 return _error
->WarningE("statvfs",_("Couldn't determine free space in %s"),
1177 return _error
->Errno("statvfs",_("Couldn't determine free space in %s"),
1179 } else if (unsigned(Buf
.f_bfree
) < (FetchBytes
- FetchPBytes
)/Buf
.f_bsize
)
1182 if (statfs(OutputDir
.c_str(),&Stat
) != 0
1183 #if HAVE_STRUCT_STATFS_F_TYPE
1184 || unsigned(Stat
.f_type
) != RAMFS_MAGIC
1187 return _error
->Error(_("You don't have enough free space in %s."),
1193 if (_config
->FindI("quiet",0) >= 2 ||
1194 _config
->FindB("APT::Get::Assume-Yes",false) == true)
1196 if (Fail
== true && _config
->FindB("APT::Get::Force-Yes",false) == false)
1197 return _error
->Error(_("There are problems and -y was used without --force-yes"));
1200 if (Essential
== true && Safety
== true)
1202 if (_config
->FindB("APT::Get::Trivial-Only",false) == true)
1203 return _error
->Error(_("Trivial Only specified but this is not a trivial operation."));
1205 const char *Prompt
= _("Yes, do as I say!");
1207 _("You are about to do something potentially harmful.\n"
1208 "To continue type in the phrase '%s'\n"
1211 if (AnalPrompt(Prompt
) == false)
1213 c2out
<< _("Abort.") << endl
;
1219 // Prompt to continue
1220 if (Ask
== true || Fail
== true)
1222 if (_config
->FindB("APT::Get::Trivial-Only",false) == true)
1223 return _error
->Error(_("Trivial Only specified but this is not a trivial operation."));
1225 if (_config
->FindI("quiet",0) < 2 &&
1226 _config
->FindB("APT::Get::Assume-Yes",false) == false)
1228 c2out
<< _("Do you want to continue [Y/n]? ") << flush
;
1230 if (YnPrompt() == false)
1232 c2out
<< _("Abort.") << endl
;
1239 // Just print out the uris an exit if the --print-uris flag was used
1240 if (_config
->FindB("APT::Get::Print-URIs") == true)
1242 pkgAcquire::UriIterator I
= Fetcher
.UriBegin();
1243 for (; I
!= Fetcher
.UriEnd(); I
++)
1244 cout
<< '\'' << I
->URI
<< "' " << flNotDir(I
->Owner
->DestFile
) << ' ' <<
1245 I
->Owner
->FileSize
<< ' ' << I
->Owner
->HashSum() << endl
;
1249 if (!CheckAuth(Fetcher
))
1252 /* Unlock the dpkg lock if we are not going to be doing an install
1254 if (_config
->FindB("APT::Get::Download-Only",false) == true)
1260 bool Transient
= false;
1261 if (_config
->FindB("APT::Get::Download",true) == false)
1263 for (pkgAcquire::ItemIterator I
= Fetcher
.ItemsBegin(); I
< Fetcher
.ItemsEnd();)
1265 if ((*I
)->Local
== true)
1271 // Close the item and check if it was found in cache
1273 if ((*I
)->Complete
== false)
1276 // Clear it out of the fetch list
1278 I
= Fetcher
.ItemsBegin();
1282 if (Fetcher
.Run() == pkgAcquire::Failed
)
1286 bool Failed
= false;
1287 for (pkgAcquire::ItemIterator I
= Fetcher
.ItemsBegin(); I
!= Fetcher
.ItemsEnd(); I
++)
1289 if ((*I
)->Status
== pkgAcquire::Item::StatDone
&&
1290 (*I
)->Complete
== true)
1293 if ((*I
)->Status
== pkgAcquire::Item::StatIdle
)
1300 fprintf(stderr
,_("Failed to fetch %s %s\n"),(*I
)->DescURI().c_str(),
1301 (*I
)->ErrorText
.c_str());
1305 /* If we are in no download mode and missing files and there were
1306 'failures' then the user must specify -m. Furthermore, there
1307 is no such thing as a transient error in no-download mode! */
1308 if (Transient
== true &&
1309 _config
->FindB("APT::Get::Download",true) == false)
1315 if (_config
->FindB("APT::Get::Download-Only",false) == true)
1317 if (Failed
== true && _config
->FindB("APT::Get::Fix-Missing",false) == false)
1318 return _error
->Error(_("Some files failed to download"));
1319 c1out
<< _("Download complete and in download only mode") << endl
;
1323 if (Failed
== true && _config
->FindB("APT::Get::Fix-Missing",false) == false)
1325 return _error
->Error(_("Unable to fetch some archives, maybe run apt-get update or try with --fix-missing?"));
1328 if (Transient
== true && Failed
== true)
1329 return _error
->Error(_("--fix-missing and media swapping is not currently supported"));
1331 // Try to deal with missing package files
1332 if (Failed
== true && PM
->FixMissing() == false)
1334 cerr
<< _("Unable to correct missing packages.") << endl
;
1335 return _error
->Error(_("Aborting install."));
1339 int status_fd
= _config
->FindI("APT::Status-Fd",-1);
1340 pkgPackageManager::OrderResult Res
= PM
->DoInstall(status_fd
);
1341 if (Res
== pkgPackageManager::Failed
|| _error
->PendingError() == true)
1343 if (Res
== pkgPackageManager::Completed
)
1346 // Reload the fetcher object and loop again for media swapping
1348 if (PM
->GetArchives(&Fetcher
,List
,&Recs
) == false)
1354 std::set
<std::string
> const disappearedPkgs
= PM
->GetDisappearedPackages();
1355 if (disappearedPkgs
.empty() == true)
1359 for (std::set
<std::string
>::const_iterator d
= disappearedPkgs
.begin();
1360 d
!= disappearedPkgs
.end(); ++d
)
1361 disappear
.append(*d
).append(" ");
1363 ShowList(c1out
, P_("The following package disappeared from your system as\n"
1364 "all files have been overwritten by other packages:",
1365 "The following packages disappeared from your system as\n"
1366 "all files have been overwritten by other packages:", disappearedPkgs
.size()), disappear
, "");
1367 c0out
<< _("Note: This is done automatic and on purpose by dpkg.") << std::endl
;
1372 // TryToInstallBuildDep - Try to install a single package /*{{{*/
1373 // ---------------------------------------------------------------------
1374 /* This used to be inlined in DoInstall, but with the advent of regex package
1375 name matching it was split out.. */
1376 bool TryToInstallBuildDep(pkgCache::PkgIterator Pkg
,pkgCacheFile
&Cache
,
1377 pkgProblemResolver
&Fix
,bool Remove
,bool BrokenFix
,
1378 bool AllowFail
= true)
1380 if (Cache
[Pkg
].CandidateVer
== 0 && Pkg
->ProvidesList
!= 0)
1382 CacheSetHelperAPTGet
helper(c1out
);
1383 helper
.showErrors(AllowFail
== false);
1384 pkgCache::VerIterator Ver
= helper
.canNotFindNewestVer(Cache
, Pkg
);
1385 if (Ver
.end() == false)
1386 Pkg
= Ver
.ParentPkg();
1387 else if (helper
.showVirtualPackageErrors(Cache
) == false)
1393 TryToRemove
RemoveAction(Cache
, &Fix
);
1394 RemoveAction(Pkg
.VersionList());
1395 } else if (Cache
[Pkg
].CandidateVer
!= 0) {
1396 TryToInstall
InstallAction(Cache
, &Fix
, BrokenFix
);
1397 InstallAction(Cache
[Pkg
].CandidateVerIter(Cache
));
1398 InstallAction
.doAutoInstall();
1405 // FindSrc - Find a source record /*{{{*/
1406 // ---------------------------------------------------------------------
1408 pkgSrcRecords::Parser
*FindSrc(const char *Name
,pkgRecords
&Recs
,
1409 pkgSrcRecords
&SrcRecs
,string
&Src
,
1413 string DefRel
= _config
->Find("APT::Default-Release");
1414 string TmpSrc
= Name
;
1416 // extract the version/release from the pkgname
1417 const size_t found
= TmpSrc
.find_last_of("/=");
1418 if (found
!= string::npos
) {
1419 if (TmpSrc
[found
] == '/')
1420 DefRel
= TmpSrc
.substr(found
+1);
1422 VerTag
= TmpSrc
.substr(found
+1);
1423 TmpSrc
= TmpSrc
.substr(0,found
);
1426 /* Lookup the version of the package we would install if we were to
1427 install a version and determine the source package name, then look
1428 in the archive for a source package of the same name. */
1429 bool MatchSrcOnly
= _config
->FindB("APT::Get::Only-Source");
1430 const pkgCache::PkgIterator Pkg
= Cache
.FindPkg(TmpSrc
);
1431 if (MatchSrcOnly
== false && Pkg
.end() == false)
1433 if(VerTag
.empty() == false || DefRel
.empty() == false)
1436 // we have a default release, try to locate the pkg. we do it like
1437 // this because GetCandidateVer() will not "downgrade", that means
1438 // "apt-get source -t stable apt" won't work on a unstable system
1439 for (pkgCache::VerIterator Ver
= Pkg
.VersionList();; Ver
++)
1441 // try first only exact matches, later fuzzy matches
1442 if (Ver
.end() == true)
1447 Ver
= Pkg
.VersionList();
1448 // exit right away from the Pkg.VersionList() loop if we
1449 // don't have any versions
1450 if (Ver
.end() == true)
1453 // We match against a concrete version (or a part of this version)
1454 if (VerTag
.empty() == false &&
1455 (fuzzy
== true || Cache
.VS().CmpVersion(VerTag
, Ver
.VerStr()) != 0) && // exact match
1456 (fuzzy
== false || strncmp(VerTag
.c_str(), Ver
.VerStr(), VerTag
.size()) != 0)) // fuzzy match
1459 for (pkgCache::VerFileIterator VF
= Ver
.FileList();
1460 VF
.end() == false; VF
++)
1462 /* If this is the status file, and the current version is not the
1463 version in the status file (ie it is not installed, or somesuch)
1464 then it is not a candidate for installation, ever. This weeds
1465 out bogus entries that may be due to config-file states, or
1467 if ((VF
.File()->Flags
& pkgCache::Flag::NotSource
) ==
1468 pkgCache::Flag::NotSource
&& Pkg
.CurrentVer() != Ver
)
1471 // or we match against a release
1472 if(VerTag
.empty() == false ||
1473 (VF
.File().Archive() != 0 && VF
.File().Archive() == DefRel
) ||
1474 (VF
.File().Codename() != 0 && VF
.File().Codename() == DefRel
))
1476 pkgRecords::Parser
&Parse
= Recs
.Lookup(VF
);
1477 Src
= Parse
.SourcePkg();
1478 // no SourcePkg name, so it is the "binary" name
1479 if (Src
.empty() == true)
1481 // the Version we have is possibly fuzzy or includes binUploads,
1482 // so we use the Version of the SourcePkg (empty if same as package)
1483 VerTag
= Parse
.SourceVer();
1484 if (VerTag
.empty() == true)
1485 VerTag
= Ver
.VerStr();
1489 if (Src
.empty() == false)
1492 if (Src
.empty() == true)
1494 // Sources files have no codename information
1495 if (VerTag
.empty() == true && DefRel
.empty() == false)
1497 _error
->Error(_("Ignore unavailable target release '%s' of package '%s'"), DefRel
.c_str(), TmpSrc
.c_str());
1502 if (Src
.empty() == true)
1504 // if we don't have found a fitting package yet so we will
1505 // choose a good candidate and proceed with that.
1506 // Maybe we will find a source later on with the right VerTag
1507 pkgCache::VerIterator Ver
= Cache
.GetCandidateVer(Pkg
);
1508 if (Ver
.end() == false)
1510 pkgRecords::Parser
&Parse
= Recs
.Lookup(Ver
.FileList());
1511 Src
= Parse
.SourcePkg();
1512 if (VerTag
.empty() == true)
1513 VerTag
= Parse
.SourceVer();
1518 if (Src
.empty() == true)
1522 /* if we have a source pkg name, make sure to only search
1523 for srcpkg names, otherwise apt gets confused if there
1524 is a binary package "pkg1" and a source package "pkg1"
1525 with the same name but that comes from different packages */
1526 MatchSrcOnly
= true;
1529 ioprintf(c1out
, _("Picking '%s' as source package instead of '%s'\n"), Src
.c_str(), TmpSrc
.c_str());
1534 pkgSrcRecords::Parser
*Last
= 0;
1535 unsigned long Offset
= 0;
1538 /* Iterate over all of the hits, which includes the resulting
1539 binary packages in the search */
1540 pkgSrcRecords::Parser
*Parse
;
1544 while ((Parse
= SrcRecs
.Find(Src
.c_str(), MatchSrcOnly
)) != 0)
1546 const string Ver
= Parse
->Version();
1548 // Ignore all versions which doesn't fit
1549 if (VerTag
.empty() == false &&
1550 Cache
.VS().CmpVersion(VerTag
, Ver
) != 0) // exact match
1553 // Newer version or an exact match? Save the hit
1554 if (Last
== 0 || Cache
.VS().CmpVersion(Version
,Ver
) < 0) {
1556 Offset
= Parse
->Offset();
1560 // was the version check above an exact match? If so, we don't need to look further
1561 if (VerTag
.empty() == false && VerTag
.size() == Ver
.size())
1564 if (Last
!= 0 || VerTag
.empty() == true)
1566 //if (VerTag.empty() == false && Last == 0)
1567 _error
->Error(_("Ignore unavailable version '%s' of package '%s'"), VerTag
.c_str(), TmpSrc
.c_str());
1571 if (Last
== 0 || Last
->Jump(Offset
) == false)
1577 // DoUpdate - Update the package lists /*{{{*/
1578 // ---------------------------------------------------------------------
1580 bool DoUpdate(CommandLine
&CmdL
)
1582 if (CmdL
.FileSize() != 1)
1583 return _error
->Error(_("The update command takes no arguments"));
1587 // Get the source list
1588 if (Cache
.BuildSourceList() == false)
1590 pkgSourceList
*List
= Cache
.GetSourceList();
1592 // Create the progress
1593 AcqTextStatus
Stat(ScreenWidth
,_config
->FindI("quiet",0));
1595 // Just print out the uris an exit if the --print-uris flag was used
1596 if (_config
->FindB("APT::Get::Print-URIs") == true)
1598 // force a hashsum for compatibility reasons
1599 _config
->CndSet("Acquire::ForceHash", "md5sum");
1603 if (Fetcher
.Setup(&Stat
) == false)
1606 // Populate it with the source selection and get all Indexes
1608 if (List
->GetIndexes(&Fetcher
,true) == false)
1611 pkgAcquire::UriIterator I
= Fetcher
.UriBegin();
1612 for (; I
!= Fetcher
.UriEnd(); I
++)
1613 cout
<< '\'' << I
->URI
<< "' " << flNotDir(I
->Owner
->DestFile
) << ' ' <<
1614 I
->Owner
->FileSize
<< ' ' << I
->Owner
->HashSum() << endl
;
1619 if (_config
->FindB("APT::Get::Download",true) == true)
1620 ListUpdate(Stat
, *List
);
1622 // Rebuild the cache.
1623 if (Cache
.BuildCaches() == false)
1629 // DoAutomaticRemove - Remove all automatic unused packages /*{{{*/
1630 // ---------------------------------------------------------------------
1631 /* Remove unused automatic packages */
1632 bool DoAutomaticRemove(CacheFile
&Cache
)
1634 bool Debug
= _config
->FindI("Debug::pkgAutoRemove",false);
1635 bool doAutoRemove
= _config
->FindB("APT::Get::AutomaticRemove", false);
1636 bool hideAutoRemove
= _config
->FindB("APT::Get::HideAutoRemove");
1638 pkgDepCache::ActionGroup
group(*Cache
);
1640 std::cout
<< "DoAutomaticRemove()" << std::endl
;
1642 if (doAutoRemove
== true &&
1643 _config
->FindB("APT::Get::Remove",true) == false)
1645 c1out
<< _("We are not supposed to delete stuff, can't start "
1646 "AutoRemover") << std::endl
;
1650 bool purgePkgs
= _config
->FindB("APT::Get::Purge", false);
1651 bool smallList
= (hideAutoRemove
== false &&
1652 strcasecmp(_config
->Find("APT::Get::HideAutoRemove","").c_str(),"small") == 0);
1654 string autoremovelist
, autoremoveversions
;
1655 unsigned long autoRemoveCount
= 0;
1656 APT::PackageSet tooMuch
;
1657 // look over the cache to see what can be removed
1658 for (pkgCache::PkgIterator Pkg
= Cache
->PkgBegin(); ! Pkg
.end(); ++Pkg
)
1660 if (Cache
[Pkg
].Garbage
)
1662 if(Pkg
.CurrentVer() != 0 || Cache
[Pkg
].Install())
1664 std::cout
<< "We could delete %s" << Pkg
.FullName(true).c_str() << std::endl
;
1668 if(Pkg
.CurrentVer() != 0 &&
1669 Pkg
->CurrentState
!= pkgCache::State::ConfigFiles
)
1670 Cache
->MarkDelete(Pkg
, purgePkgs
);
1672 Cache
->MarkKeep(Pkg
, false, false);
1676 // if the package is a new install and already garbage we don't need to
1677 // install it in the first place, so nuke it instead of show it
1678 if (Cache
[Pkg
].Install() == true && Pkg
.CurrentVer() == 0)
1680 Cache
->MarkDelete(Pkg
, false);
1681 tooMuch
.insert(Pkg
);
1683 // only show stuff in the list that is not yet marked for removal
1684 else if(hideAutoRemove
== false && Cache
[Pkg
].Delete() == false)
1687 // we don't need to fill the strings if we don't need them
1688 if (smallList
== false)
1690 autoremovelist
+= Pkg
.FullName(true) + " ";
1691 autoremoveversions
+= string(Cache
[Pkg
].CandVersion
) + "\n";
1698 // we could have removed a new dependency of a garbage package,
1699 // so check if a reverse depends is broken and if so install it again.
1700 if (tooMuch
.empty() == false && Cache
->BrokenCount() != 0)
1705 for (APT::PackageSet::const_iterator P
= tooMuch
.begin();
1706 P
!= tooMuch
.end() && Changed
== false; ++P
)
1708 for (pkgCache::DepIterator R
= P
.RevDependsList();
1709 R
.end() == false; ++R
)
1711 if (R
->Type
!= pkgCache::Dep::Depends
&&
1712 R
->Type
!= pkgCache::Dep::PreDepends
)
1714 pkgCache::PkgIterator N
= R
.ParentPkg();
1715 if (N
.end() == true || (N
->CurrentVer
== 0 && (*Cache
)[N
].Install() == false))
1718 std::clog
<< "Save " << P
<< " as another installed garbage package depends on it" << std::endl
;
1719 Cache
->MarkInstall(P
, false);
1720 if(hideAutoRemove
== false)
1723 if (smallList
== false)
1725 autoremovelist
+= P
.FullName(true) + " ";
1726 autoremoveversions
+= string(Cache
[P
].CandVersion
) + "\n";
1734 } while (Changed
== true);
1737 // Now see if we had destroyed anything (if we had done anything)
1738 if (Cache
->BrokenCount() != 0)
1740 c1out
<< _("Hmm, seems like the AutoRemover destroyed something which really\n"
1741 "shouldn't happen. Please file a bug report against apt.") << endl
;
1743 c1out
<< _("The following information may help to resolve the situation:") << endl
;
1745 ShowBroken(c1out
,Cache
,false);
1747 return _error
->Error(_("Internal Error, AutoRemover broke stuff"));
1750 // if we don't remove them, we should show them!
1751 if (doAutoRemove
== false && (autoremovelist
.empty() == false || autoRemoveCount
!= 0))
1753 if (smallList
== false)
1754 ShowList(c1out
, P_("The following package was automatically installed and is no longer required:",
1755 "The following packages were automatically installed and are no longer required:",
1756 autoRemoveCount
), autoremovelist
, autoremoveversions
);
1758 ioprintf(c1out
, P_("%lu package was automatically installed and is no longer required.\n",
1759 "%lu packages were automatically installed and are no longer required.\n", autoRemoveCount
), autoRemoveCount
);
1760 c1out
<< _("Use 'apt-get autoremove' to remove them.") << std::endl
;
1765 // DoUpgrade - Upgrade all packages /*{{{*/
1766 // ---------------------------------------------------------------------
1767 /* Upgrade all packages without installing new packages or erasing old
1769 bool DoUpgrade(CommandLine
&CmdL
)
1772 if (Cache
.OpenForInstall() == false || Cache
.CheckDeps() == false)
1776 if (pkgAllUpgrade(Cache
) == false)
1778 ShowBroken(c1out
,Cache
,false);
1779 return _error
->Error(_("Internal error, AllUpgrade broke stuff"));
1782 return InstallPackages(Cache
,true);
1785 // DoInstall - Install packages from the command line /*{{{*/
1786 // ---------------------------------------------------------------------
1787 /* Install named packages */
1788 bool DoInstall(CommandLine
&CmdL
)
1791 if (Cache
.OpenForInstall() == false ||
1792 Cache
.CheckDeps(CmdL
.FileSize() != 1) == false)
1795 // Enter the special broken fixing mode if the user specified arguments
1796 bool BrokenFix
= false;
1797 if (Cache
->BrokenCount() != 0)
1800 pkgProblemResolver
* Fix
= NULL
;
1801 if (_config
->FindB("APT::Get::CallResolver", true) == true)
1802 Fix
= new pkgProblemResolver(Cache
);
1804 static const unsigned short MOD_REMOVE
= 1;
1805 static const unsigned short MOD_INSTALL
= 2;
1807 unsigned short fallback
= MOD_INSTALL
;
1808 if (strcasecmp(CmdL
.FileList
[0],"remove") == 0)
1809 fallback
= MOD_REMOVE
;
1810 else if (strcasecmp(CmdL
.FileList
[0], "purge") == 0)
1812 _config
->Set("APT::Get::Purge", true);
1813 fallback
= MOD_REMOVE
;
1815 else if (strcasecmp(CmdL
.FileList
[0], "autoremove") == 0)
1817 _config
->Set("APT::Get::AutomaticRemove", "true");
1818 fallback
= MOD_REMOVE
;
1821 std::list
<APT::VersionSet::Modifier
> mods
;
1822 mods
.push_back(APT::VersionSet::Modifier(MOD_INSTALL
, "+",
1823 APT::VersionSet::Modifier::POSTFIX
, APT::VersionSet::CANDIDATE
));
1824 mods
.push_back(APT::VersionSet::Modifier(MOD_REMOVE
, "-",
1825 APT::VersionSet::Modifier::POSTFIX
, APT::VersionSet::NEWEST
));
1826 CacheSetHelperAPTGet
helper(c0out
);
1827 std::map
<unsigned short, APT::VersionSet
> verset
= APT::VersionSet::GroupedFromCommandLine(Cache
,
1828 CmdL
.FileList
+ 1, mods
, fallback
, helper
);
1830 if (_error
->PendingError() == true)
1832 helper
.showVirtualPackageErrors(Cache
);
1838 unsigned short const order
[] = { MOD_REMOVE
, MOD_INSTALL
, 0 };
1840 TryToInstall
InstallAction(Cache
, Fix
, BrokenFix
);
1841 TryToRemove
RemoveAction(Cache
, Fix
);
1843 // new scope for the ActionGroup
1845 pkgDepCache::ActionGroup
group(Cache
);
1847 for (unsigned short i
= 0; order
[i
] != 0; ++i
)
1849 if (order
[i
] == MOD_INSTALL
)
1850 InstallAction
= std::for_each(verset
[MOD_INSTALL
].begin(), verset
[MOD_INSTALL
].end(), InstallAction
);
1851 else if (order
[i
] == MOD_REMOVE
)
1852 RemoveAction
= std::for_each(verset
[MOD_REMOVE
].begin(), verset
[MOD_REMOVE
].end(), RemoveAction
);
1855 if (Fix
!= NULL
&& _config
->FindB("APT::Get::AutoSolving", true) == true)
1857 for (unsigned short i
= 0; order
[i
] != 0; ++i
)
1859 if (order
[i
] != MOD_INSTALL
)
1861 InstallAction
.propergateReleaseCandiateSwitching(helper
.selectedByRelease
, c0out
);
1862 InstallAction
.doAutoInstall();
1866 if (_error
->PendingError() == true)
1873 /* If we are in the Broken fixing mode we do not attempt to fix the
1874 problems. This is if the user invoked install without -f and gave
1876 if (BrokenFix
== true && Cache
->BrokenCount() != 0)
1878 c1out
<< _("You might want to run 'apt-get -f install' to correct these:") << endl
;
1879 ShowBroken(c1out
,Cache
,false);
1882 return _error
->Error(_("Unmet dependencies. Try 'apt-get -f install' with no packages (or specify a solution)."));
1887 // Call the scored problem resolver
1888 Fix
->InstallProtect();
1893 // Now we check the state of the packages,
1894 if (Cache
->BrokenCount() != 0)
1897 _("Some packages could not be installed. This may mean that you have\n"
1898 "requested an impossible situation or if you are using the unstable\n"
1899 "distribution that some required packages have not yet been created\n"
1900 "or been moved out of Incoming.") << endl
;
1906 _("Since you only requested a single operation it is extremely likely that\n"
1907 "the package is simply not installable and a bug report against\n"
1908 "that package should be filed.") << endl;
1912 c1out
<< _("The following information may help to resolve the situation:") << endl
;
1914 ShowBroken(c1out
,Cache
,false);
1915 if (_error
->PendingError() == true)
1918 return _error
->Error(_("Broken packages"));
1921 if (!DoAutomaticRemove(Cache
))
1924 /* Print out a list of packages that are going to be installed extra
1925 to what the user asked */
1926 if (Cache
->InstCount() != verset
[MOD_INSTALL
].size())
1929 string VersionsList
;
1930 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
1932 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
1933 if ((*Cache
)[I
].Install() == false)
1935 pkgCache::VerIterator Cand
= Cache
[I
].CandidateVerIter(Cache
);
1937 if (verset
[MOD_INSTALL
].find(Cand
) != verset
[MOD_INSTALL
].end())
1940 List
+= I
.FullName(true) + " ";
1941 VersionsList
+= string(Cache
[I
].CandVersion
) + "\n";
1944 ShowList(c1out
,_("The following extra packages will be installed:"),List
,VersionsList
);
1947 /* Print out a list of suggested and recommended packages */
1949 string SuggestsList
, RecommendsList
, List
;
1950 string SuggestsVersions
, RecommendsVersions
;
1951 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
1953 pkgCache::PkgIterator
Pkg(Cache
,Cache
.List
[J
]);
1955 /* Just look at the ones we want to install */
1956 if ((*Cache
)[Pkg
].Install() == false)
1959 // get the recommends/suggests for the candidate ver
1960 pkgCache::VerIterator CV
= (*Cache
)[Pkg
].CandidateVerIter(*Cache
);
1961 for (pkgCache::DepIterator D
= CV
.DependsList(); D
.end() == false; )
1963 pkgCache::DepIterator Start
;
1964 pkgCache::DepIterator End
;
1965 D
.GlobOr(Start
,End
); // advances D
1967 // FIXME: we really should display a or-group as a or-group to the user
1968 // the problem is that ShowList is incapable of doing this
1969 string RecommendsOrList
,RecommendsOrVersions
;
1970 string SuggestsOrList
,SuggestsOrVersions
;
1971 bool foundInstalledInOrGroup
= false;
1974 /* Skip if package is installed already, or is about to be */
1975 string target
= Start
.TargetPkg().FullName(true) + " ";
1976 pkgCache::PkgIterator
const TarPkg
= Start
.TargetPkg();
1977 if (TarPkg
->SelectedState
== pkgCache::State::Install
||
1978 TarPkg
->SelectedState
== pkgCache::State::Hold
||
1979 Cache
[Start
.TargetPkg()].Install())
1981 foundInstalledInOrGroup
=true;
1985 /* Skip if we already saw it */
1986 if (int(SuggestsList
.find(target
)) != -1 || int(RecommendsList
.find(target
)) != -1)
1988 foundInstalledInOrGroup
=true;
1992 // this is a dep on a virtual pkg, check if any package that provides it
1993 // should be installed
1994 if(Start
.TargetPkg().ProvidesList() != 0)
1996 pkgCache::PrvIterator I
= Start
.TargetPkg().ProvidesList();
1997 for (; I
.end() == false; I
++)
1999 pkgCache::PkgIterator Pkg
= I
.OwnerPkg();
2000 if (Cache
[Pkg
].CandidateVerIter(Cache
) == I
.OwnerVer() &&
2001 Pkg
.CurrentVer() != 0)
2002 foundInstalledInOrGroup
=true;
2006 if (Start
->Type
== pkgCache::Dep::Suggests
)
2008 SuggestsOrList
+= target
;
2009 SuggestsOrVersions
+= string(Cache
[Start
.TargetPkg()].CandVersion
) + "\n";
2012 if (Start
->Type
== pkgCache::Dep::Recommends
)
2014 RecommendsOrList
+= target
;
2015 RecommendsOrVersions
+= string(Cache
[Start
.TargetPkg()].CandVersion
) + "\n";
2023 if(foundInstalledInOrGroup
== false)
2025 RecommendsList
+= RecommendsOrList
;
2026 RecommendsVersions
+= RecommendsOrVersions
;
2027 SuggestsList
+= SuggestsOrList
;
2028 SuggestsVersions
+= SuggestsOrVersions
;
2034 ShowList(c1out
,_("Suggested packages:"),SuggestsList
,SuggestsVersions
);
2035 ShowList(c1out
,_("Recommended packages:"),RecommendsList
,RecommendsVersions
);
2039 // if nothing changed in the cache, but only the automark information
2040 // we write the StateFile here, otherwise it will be written in
2042 if (InstallAction
.AutoMarkChanged
> 0 &&
2043 Cache
->DelCount() == 0 && Cache
->InstCount() == 0 &&
2044 Cache
->BadCount() == 0 &&
2045 _config
->FindB("APT::Get::Simulate",false) == false)
2046 Cache
->writeStateFile(NULL
);
2048 // See if we need to prompt
2049 // FIXME: check if really the packages in the set are going to be installed
2050 if (Cache
->InstCount() == verset
[MOD_INSTALL
].size() && Cache
->DelCount() == 0)
2051 return InstallPackages(Cache
,false,false);
2053 return InstallPackages(Cache
,false);
2056 /* mark packages as automatically/manually installed. {{{*/
2057 bool DoMarkAuto(CommandLine
&CmdL
)
2060 int AutoMarkChanged
= 0;
2061 OpTextProgress progress
;
2063 if (Cache
.Open() == false)
2066 if (strcasecmp(CmdL
.FileList
[0],"markauto") == 0)
2068 else if (strcasecmp(CmdL
.FileList
[0],"unmarkauto") == 0)
2071 for (const char **I
= CmdL
.FileList
+ 1; *I
!= 0; I
++)
2074 // Locate the package
2075 pkgCache::PkgIterator Pkg
= Cache
->FindPkg(S
);
2076 if (Pkg
.end() == true) {
2077 return _error
->Error(_("Couldn't find package %s"),S
);
2082 ioprintf(c1out
,_("%s set to manually installed.\n"), Pkg
.Name());
2084 ioprintf(c1out
,_("%s set to automatically installed.\n"),
2087 Cache
->MarkAuto(Pkg
,Action
);
2092 _error
->Notice(_("This command is deprecated. Please use 'apt-mark auto' and 'apt-mark manual' instead."));
2094 if (AutoMarkChanged
&& ! _config
->FindB("APT::Get::Simulate",false))
2095 return Cache
->writeStateFile(NULL
);
2099 // DoDistUpgrade - Automatic smart upgrader /*{{{*/
2100 // ---------------------------------------------------------------------
2101 /* Intelligent upgrader that will install and remove packages at will */
2102 bool DoDistUpgrade(CommandLine
&CmdL
)
2105 if (Cache
.OpenForInstall() == false || Cache
.CheckDeps() == false)
2108 c0out
<< _("Calculating upgrade... ") << flush
;
2109 if (pkgDistUpgrade(*Cache
) == false)
2111 c0out
<< _("Failed") << endl
;
2112 ShowBroken(c1out
,Cache
,false);
2116 c0out
<< _("Done") << endl
;
2118 return InstallPackages(Cache
,true);
2121 // DoDSelectUpgrade - Do an upgrade by following dselects selections /*{{{*/
2122 // ---------------------------------------------------------------------
2123 /* Follows dselect's selections */
2124 bool DoDSelectUpgrade(CommandLine
&CmdL
)
2127 if (Cache
.OpenForInstall() == false || Cache
.CheckDeps() == false)
2130 pkgDepCache::ActionGroup
group(Cache
);
2132 // Install everything with the install flag set
2133 pkgCache::PkgIterator I
= Cache
->PkgBegin();
2134 for (;I
.end() != true; I
++)
2136 /* Install the package only if it is a new install, the autoupgrader
2137 will deal with the rest */
2138 if (I
->SelectedState
== pkgCache::State::Install
)
2139 Cache
->MarkInstall(I
,false);
2142 /* Now install their deps too, if we do this above then order of
2143 the status file is significant for | groups */
2144 for (I
= Cache
->PkgBegin();I
.end() != true; I
++)
2146 /* Install the package only if it is a new install, the autoupgrader
2147 will deal with the rest */
2148 if (I
->SelectedState
== pkgCache::State::Install
)
2149 Cache
->MarkInstall(I
,true);
2152 // Apply erasures now, they override everything else.
2153 for (I
= Cache
->PkgBegin();I
.end() != true; I
++)
2156 if (I
->SelectedState
== pkgCache::State::DeInstall
||
2157 I
->SelectedState
== pkgCache::State::Purge
)
2158 Cache
->MarkDelete(I
,I
->SelectedState
== pkgCache::State::Purge
);
2161 /* Resolve any problems that dselect created, allupgrade cannot handle
2162 such things. We do so quite agressively too.. */
2163 if (Cache
->BrokenCount() != 0)
2165 pkgProblemResolver
Fix(Cache
);
2167 // Hold back held packages.
2168 if (_config
->FindB("APT::Ignore-Hold",false) == false)
2170 for (pkgCache::PkgIterator I
= Cache
->PkgBegin(); I
.end() == false; I
++)
2172 if (I
->SelectedState
== pkgCache::State::Hold
)
2180 if (Fix
.Resolve() == false)
2182 ShowBroken(c1out
,Cache
,false);
2183 return _error
->Error(_("Internal error, problem resolver broke stuff"));
2187 // Now upgrade everything
2188 if (pkgAllUpgrade(Cache
) == false)
2190 ShowBroken(c1out
,Cache
,false);
2191 return _error
->Error(_("Internal error, problem resolver broke stuff"));
2194 return InstallPackages(Cache
,false);
2197 // DoClean - Remove download archives /*{{{*/
2198 // ---------------------------------------------------------------------
2200 bool DoClean(CommandLine
&CmdL
)
2202 if (_config
->FindB("APT::Get::Simulate") == true)
2204 cout
<< "Del " << _config
->FindDir("Dir::Cache::archives") << "* " <<
2205 _config
->FindDir("Dir::Cache::archives") << "partial/*" << endl
;
2209 // Lock the archive directory
2211 if (_config
->FindB("Debug::NoLocking",false) == false)
2213 Lock
.Fd(GetLock(_config
->FindDir("Dir::Cache::Archives") + "lock"));
2214 if (_error
->PendingError() == true)
2215 return _error
->Error(_("Unable to lock the download directory"));
2219 Fetcher
.Clean(_config
->FindDir("Dir::Cache::archives"));
2220 Fetcher
.Clean(_config
->FindDir("Dir::Cache::archives") + "partial/");
2224 // DoAutoClean - Smartly remove downloaded archives /*{{{*/
2225 // ---------------------------------------------------------------------
2226 /* This is similar to clean but it only purges things that cannot be
2227 downloaded, that is old versions of cached packages. */
2228 class LogCleaner
: public pkgArchiveCleaner
2231 virtual void Erase(const char *File
,string Pkg
,string Ver
,struct stat
&St
)
2233 c1out
<< "Del " << Pkg
<< " " << Ver
<< " [" << SizeToStr(St
.st_size
) << "B]" << endl
;
2235 if (_config
->FindB("APT::Get::Simulate") == false)
2240 bool DoAutoClean(CommandLine
&CmdL
)
2242 // Lock the archive directory
2244 if (_config
->FindB("Debug::NoLocking",false) == false)
2246 Lock
.Fd(GetLock(_config
->FindDir("Dir::Cache::Archives") + "lock"));
2247 if (_error
->PendingError() == true)
2248 return _error
->Error(_("Unable to lock the download directory"));
2252 if (Cache
.Open() == false)
2257 return Cleaner
.Go(_config
->FindDir("Dir::Cache::archives"),*Cache
) &&
2258 Cleaner
.Go(_config
->FindDir("Dir::Cache::archives") + "partial/",*Cache
);
2261 // DoDownload - download a binary /*{{{*/
2262 // ---------------------------------------------------------------------
2263 bool DoDownload(CommandLine
&CmdL
)
2266 if (Cache
.ReadOnlyOpen() == false)
2269 APT::CacheSetHelper
helper(c0out
);
2270 APT::VersionSet verset
= APT::VersionSet::FromCommandLine(Cache
,
2271 CmdL
.FileList
+ 1, APT::VersionSet::CANDIDATE
, helper
);
2273 if (verset
.empty() == true)
2277 AcqTextStatus
Stat(ScreenWidth
, _config
->FindI("quiet",0));
2278 if (_config
->FindB("APT::Get::Print-URIs") == true)
2279 Fetcher
.Setup(&Stat
);
2281 pkgRecords
Recs(Cache
);
2282 pkgSourceList
*SrcList
= Cache
.GetSourceList();
2283 for (APT::VersionSet::const_iterator Ver
= verset
.begin();
2284 Ver
!= verset
.end();
2288 // get the right version
2289 pkgCache::PkgIterator Pkg
= Ver
.ParentPkg();
2290 pkgRecords::Parser
&rec
=Recs
.Lookup(Ver
.FileList());
2291 pkgCache::VerFileIterator Vf
= Ver
.FileList();
2292 if (Vf
.end() == true)
2293 return _error
->Error("Can not find VerFile");
2294 pkgCache::PkgFileIterator F
= Vf
.File();
2295 pkgIndexFile
*index
;
2296 if(SrcList
->FindIndex(F
, index
) == false)
2297 return _error
->Error("FindIndex failed");
2298 string uri
= index
->ArchiveURI(rec
.FileName());
2299 strprintf(descr
, _("Downloading %s %s"), Pkg
.Name(), Ver
.VerStr());
2300 // get the most appropriate hash
2302 if (rec
.SHA512Hash() != "")
2303 hash
= HashString("sha512", rec
.SHA512Hash());
2304 if (rec
.SHA256Hash() != "")
2305 hash
= HashString("sha256", rec
.SHA256Hash());
2306 else if (rec
.SHA1Hash() != "")
2307 hash
= HashString("sha1", rec
.SHA1Hash());
2308 else if (rec
.MD5Hash() != "")
2309 hash
= HashString("md5", rec
.MD5Hash());
2311 new pkgAcqFile(&Fetcher
, uri
, hash
.toStr(), (*Ver
)->Size
, descr
, Pkg
.Name(), ".");
2314 // Just print out the uris and exit if the --print-uris flag was used
2315 if (_config
->FindB("APT::Get::Print-URIs") == true)
2317 pkgAcquire::UriIterator I
= Fetcher
.UriBegin();
2318 for (; I
!= Fetcher
.UriEnd(); I
++)
2319 cout
<< '\'' << I
->URI
<< "' " << flNotDir(I
->Owner
->DestFile
) << ' ' <<
2320 I
->Owner
->FileSize
<< ' ' << I
->Owner
->HashSum() << endl
;
2324 return (Fetcher
.Run() == pkgAcquire::Continue
);
2327 // DoCheck - Perform the check operation /*{{{*/
2328 // ---------------------------------------------------------------------
2329 /* Opening automatically checks the system, this command is mostly used
2331 bool DoCheck(CommandLine
&CmdL
)
2340 // DoSource - Fetch a source archive /*{{{*/
2341 // ---------------------------------------------------------------------
2342 /* Fetch souce packages */
2350 bool DoSource(CommandLine
&CmdL
)
2353 if (Cache
.Open(false) == false)
2356 if (CmdL
.FileSize() <= 1)
2357 return _error
->Error(_("Must specify at least one package to fetch source for"));
2359 // Read the source list
2360 if (Cache
.BuildSourceList() == false)
2362 pkgSourceList
*List
= Cache
.GetSourceList();
2364 // Create the text record parsers
2365 pkgRecords
Recs(Cache
);
2366 pkgSrcRecords
SrcRecs(*List
);
2367 if (_error
->PendingError() == true)
2370 // Create the download object
2371 AcqTextStatus
Stat(ScreenWidth
,_config
->FindI("quiet",0));
2373 if (Fetcher
.Setup(&Stat
) == false)
2376 DscFile
*Dsc
= new DscFile
[CmdL
.FileSize()];
2378 // insert all downloaded uris into this set to avoid downloading them
2382 // Diff only mode only fetches .diff files
2383 bool const diffOnly
= _config
->FindB("APT::Get::Diff-Only", false);
2384 // Tar only mode only fetches .tar files
2385 bool const tarOnly
= _config
->FindB("APT::Get::Tar-Only", false);
2386 // Dsc only mode only fetches .dsc files
2387 bool const dscOnly
= _config
->FindB("APT::Get::Dsc-Only", false);
2389 // Load the requestd sources into the fetcher
2391 for (const char **I
= CmdL
.FileList
+ 1; *I
!= 0; I
++, J
++)
2394 pkgSrcRecords::Parser
*Last
= FindSrc(*I
,Recs
,SrcRecs
,Src
,*Cache
);
2398 return _error
->Error(_("Unable to find a source package for %s"),Src
.c_str());
2401 string srec
= Last
->AsStr();
2402 string::size_type pos
= srec
.find("\nVcs-");
2403 while (pos
!= string::npos
)
2405 pos
+= strlen("\nVcs-");
2406 string vcs
= srec
.substr(pos
,srec
.find(":",pos
)-pos
);
2407 if(vcs
== "Browser")
2409 pos
= srec
.find("\nVcs-", pos
);
2412 pos
+= vcs
.length()+2;
2413 string::size_type epos
= srec
.find("\n", pos
);
2414 string uri
= srec
.substr(pos
,epos
-pos
).c_str();
2415 ioprintf(c1out
, _("NOTICE: '%s' packaging is maintained in "
2416 "the '%s' version control system at:\n"
2418 Src
.c_str(), vcs
.c_str(), uri
.c_str());
2420 ioprintf(c1out
,_("Please use:\n"
2422 "to retrieve the latest (possibly unreleased) "
2423 "updates to the package.\n"),
2429 vector
<pkgSrcRecords::File
> Lst
;
2430 if (Last
->Files(Lst
) == false) {
2435 // Load them into the fetcher
2436 for (vector
<pkgSrcRecords::File
>::const_iterator I
= Lst
.begin();
2437 I
!= Lst
.end(); I
++)
2439 // Try to guess what sort of file it is we are getting.
2440 if (I
->Type
== "dsc")
2442 Dsc
[J
].Package
= Last
->Package();
2443 Dsc
[J
].Version
= Last
->Version();
2444 Dsc
[J
].Dsc
= flNotDir(I
->Path
);
2447 // Handle the only options so that multiple can be used at once
2448 if (diffOnly
== true || tarOnly
== true || dscOnly
== true)
2450 if ((diffOnly
== true && I
->Type
== "diff") ||
2451 (tarOnly
== true && I
->Type
== "tar") ||
2452 (dscOnly
== true && I
->Type
== "dsc"))
2453 ; // Fine, we want this file downloaded
2458 // don't download the same uri twice (should this be moved to
2459 // the fetcher interface itself?)
2460 if(queued
.find(Last
->Index().ArchiveURI(I
->Path
)) != queued
.end())
2462 queued
.insert(Last
->Index().ArchiveURI(I
->Path
));
2464 // check if we have a file with that md5 sum already localy
2465 if(!I
->MD5Hash
.empty() && FileExists(flNotDir(I
->Path
)))
2467 FileFd
Fd(flNotDir(I
->Path
), FileFd::ReadOnly
);
2469 sum
.AddFD(Fd
.Fd(), Fd
.Size());
2471 if((string
)sum
.Result() == I
->MD5Hash
)
2473 ioprintf(c1out
,_("Skipping already downloaded file '%s'\n"),
2474 flNotDir(I
->Path
).c_str());
2479 new pkgAcqFile(&Fetcher
,Last
->Index().ArchiveURI(I
->Path
),
2481 Last
->Index().SourceInfo(*Last
,*I
),Src
);
2485 // Display statistics
2486 unsigned long long FetchBytes
= Fetcher
.FetchNeeded();
2487 unsigned long long FetchPBytes
= Fetcher
.PartialPresent();
2488 unsigned long long DebBytes
= Fetcher
.TotalNeeded();
2490 // Check for enough free space
2492 string OutputDir
= ".";
2493 if (statvfs(OutputDir
.c_str(),&Buf
) != 0) {
2495 if (errno
== EOVERFLOW
)
2496 return _error
->WarningE("statvfs",_("Couldn't determine free space in %s"),
2499 return _error
->Errno("statvfs",_("Couldn't determine free space in %s"),
2501 } else if (unsigned(Buf
.f_bfree
) < (FetchBytes
- FetchPBytes
)/Buf
.f_bsize
)
2504 if (statfs(OutputDir
.c_str(),&Stat
) != 0
2505 #if HAVE_STRUCT_STATFS_F_TYPE
2506 || unsigned(Stat
.f_type
) != RAMFS_MAGIC
2510 return _error
->Error(_("You don't have enough free space in %s"),
2516 if (DebBytes
!= FetchBytes
)
2517 //TRANSLATOR: The required space between number and unit is already included
2518 // in the replacement strings, so %sB will be correctly translate in e.g. 1,5 MB
2519 ioprintf(c1out
,_("Need to get %sB/%sB of source archives.\n"),
2520 SizeToStr(FetchBytes
).c_str(),SizeToStr(DebBytes
).c_str());
2522 //TRANSLATOR: The required space between number and unit is already included
2523 // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
2524 ioprintf(c1out
,_("Need to get %sB of source archives.\n"),
2525 SizeToStr(DebBytes
).c_str());
2527 if (_config
->FindB("APT::Get::Simulate",false) == true)
2529 for (unsigned I
= 0; I
!= J
; I
++)
2530 ioprintf(cout
,_("Fetch source %s\n"),Dsc
[I
].Package
.c_str());
2535 // Just print out the uris an exit if the --print-uris flag was used
2536 if (_config
->FindB("APT::Get::Print-URIs") == true)
2538 pkgAcquire::UriIterator I
= Fetcher
.UriBegin();
2539 for (; I
!= Fetcher
.UriEnd(); I
++)
2540 cout
<< '\'' << I
->URI
<< "' " << flNotDir(I
->Owner
->DestFile
) << ' ' <<
2541 I
->Owner
->FileSize
<< ' ' << I
->Owner
->HashSum() << endl
;
2547 if (Fetcher
.Run() == pkgAcquire::Failed
)
2553 // Print error messages
2554 bool Failed
= false;
2555 for (pkgAcquire::ItemIterator I
= Fetcher
.ItemsBegin(); I
!= Fetcher
.ItemsEnd(); I
++)
2557 if ((*I
)->Status
== pkgAcquire::Item::StatDone
&&
2558 (*I
)->Complete
== true)
2561 fprintf(stderr
,_("Failed to fetch %s %s\n"),(*I
)->DescURI().c_str(),
2562 (*I
)->ErrorText
.c_str());
2568 return _error
->Error(_("Failed to fetch some archives."));
2571 if (_config
->FindB("APT::Get::Download-only",false) == true)
2573 c1out
<< _("Download complete and in download only mode") << endl
;
2578 // Unpack the sources
2579 pid_t Process
= ExecFork();
2583 bool const fixBroken
= _config
->FindB("APT::Get::Fix-Broken", false);
2584 for (unsigned I
= 0; I
!= J
; I
++)
2586 string Dir
= Dsc
[I
].Package
+ '-' + Cache
->VS().UpstreamVersion(Dsc
[I
].Version
.c_str());
2588 // Diff only mode only fetches .diff files
2589 if (_config
->FindB("APT::Get::Diff-Only",false) == true ||
2590 _config
->FindB("APT::Get::Tar-Only",false) == true ||
2591 Dsc
[I
].Dsc
.empty() == true)
2594 // See if the package is already unpacked
2596 if (fixBroken
== false && stat(Dir
.c_str(),&Stat
) == 0 &&
2597 S_ISDIR(Stat
.st_mode
) != 0)
2599 ioprintf(c0out
,_("Skipping unpack of already unpacked source in %s\n"),
2606 snprintf(S
,sizeof(S
),"%s -x %s",
2607 _config
->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(),
2608 Dsc
[I
].Dsc
.c_str());
2611 fprintf(stderr
,_("Unpack command '%s' failed.\n"),S
);
2612 fprintf(stderr
,_("Check if the 'dpkg-dev' package is installed.\n"));
2617 // Try to compile it with dpkg-buildpackage
2618 if (_config
->FindB("APT::Get::Compile",false) == true)
2620 // Call dpkg-buildpackage
2622 snprintf(S
,sizeof(S
),"cd %s && %s %s",
2624 _config
->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(),
2625 _config
->Find("DPkg::Build-Options","-b -uc").c_str());
2629 fprintf(stderr
,_("Build command '%s' failed.\n"),S
);
2639 // Wait for the subprocess
2641 while (waitpid(Process
,&Status
,0) != Process
)
2645 return _error
->Errno("waitpid","Couldn't wait for subprocess");
2648 if (WIFEXITED(Status
) == 0 || WEXITSTATUS(Status
) != 0)
2649 return _error
->Error(_("Child process failed"));
2654 // DoBuildDep - Install/removes packages to satisfy build dependencies /*{{{*/
2655 // ---------------------------------------------------------------------
2656 /* This function will look at the build depends list of the given source
2657 package and install the necessary packages to make it true, or fail. */
2658 bool DoBuildDep(CommandLine
&CmdL
)
2662 _config
->Set("APT::Install-Recommends", false);
2664 if (Cache
.Open(true) == false)
2667 if (CmdL
.FileSize() <= 1)
2668 return _error
->Error(_("Must specify at least one package to check builddeps for"));
2670 // Read the source list
2671 if (Cache
.BuildSourceList() == false)
2673 pkgSourceList
*List
= Cache
.GetSourceList();
2675 // Create the text record parsers
2676 pkgRecords
Recs(Cache
);
2677 pkgSrcRecords
SrcRecs(*List
);
2678 if (_error
->PendingError() == true)
2681 // Create the download object
2682 AcqTextStatus
Stat(ScreenWidth
,_config
->FindI("quiet",0));
2684 if (Fetcher
.Setup(&Stat
) == false)
2688 bool const StripMultiArch
= APT::Configuration::getArchitectures().size() <= 1;
2689 for (const char **I
= CmdL
.FileList
+ 1; *I
!= 0; I
++, J
++)
2692 pkgSrcRecords::Parser
*Last
= FindSrc(*I
,Recs
,SrcRecs
,Src
,*Cache
);
2694 return _error
->Error(_("Unable to find a source package for %s"),Src
.c_str());
2696 // Process the build-dependencies
2697 vector
<pkgSrcRecords::Parser::BuildDepRec
> BuildDeps
;
2698 if (Last
->BuildDepends(BuildDeps
, _config
->FindB("APT::Get::Arch-Only", false), StripMultiArch
) == false)
2699 return _error
->Error(_("Unable to get build-dependency information for %s"),Src
.c_str());
2701 // Also ensure that build-essential packages are present
2702 Configuration::Item
const *Opts
= _config
->Tree("APT::Build-Essential");
2705 for (; Opts
; Opts
= Opts
->Next
)
2707 if (Opts
->Value
.empty() == true)
2710 pkgSrcRecords::Parser::BuildDepRec rec
;
2711 rec
.Package
= Opts
->Value
;
2712 rec
.Type
= pkgSrcRecords::Parser::BuildDependIndep
;
2714 BuildDeps
.push_back(rec
);
2717 if (BuildDeps
.size() == 0)
2719 ioprintf(c1out
,_("%s has no build depends.\n"),Src
.c_str());
2723 // Install the requested packages
2724 vector
<pkgSrcRecords::Parser::BuildDepRec
>::iterator D
;
2725 pkgProblemResolver
Fix(Cache
);
2726 bool skipAlternatives
= false; // skip remaining alternatives in an or group
2727 for (D
= BuildDeps
.begin(); D
!= BuildDeps
.end(); D
++)
2729 bool hasAlternatives
= (((*D
).Op
& pkgCache::Dep::Or
) == pkgCache::Dep::Or
);
2731 if (skipAlternatives
== true)
2733 if (!hasAlternatives
)
2734 skipAlternatives
= false; // end of or group
2738 if ((*D
).Type
== pkgSrcRecords::Parser::BuildConflict
||
2739 (*D
).Type
== pkgSrcRecords::Parser::BuildConflictIndep
)
2741 pkgCache::PkgIterator Pkg
= Cache
->FindPkg((*D
).Package
);
2742 // Build-conflicts on unknown packages are silently ignored
2743 if (Pkg
.end() == true)
2746 pkgCache::VerIterator IV
= (*Cache
)[Pkg
].InstVerIter(*Cache
);
2749 * Remove if we have an installed version that satisfies the
2752 if (IV
.end() == false &&
2753 Cache
->VS().CheckDep(IV
.VerStr(),(*D
).Op
,(*D
).Version
.c_str()) == true)
2754 TryToInstallBuildDep(Pkg
,Cache
,Fix
,true,false);
2756 else // BuildDep || BuildDepIndep
2758 pkgCache::PkgIterator Pkg
= Cache
->FindPkg((*D
).Package
);
2759 if (_config
->FindB("Debug::BuildDeps",false) == true)
2760 cout
<< "Looking for " << (*D
).Package
<< "...\n";
2762 if (Pkg
.end() == true)
2764 if (_config
->FindB("Debug::BuildDeps",false) == true)
2765 cout
<< " (not found)" << (*D
).Package
<< endl
;
2767 if (hasAlternatives
)
2770 return _error
->Error(_("%s dependency for %s cannot be satisfied "
2771 "because the package %s cannot be found"),
2772 Last
->BuildDepType((*D
).Type
),Src
.c_str(),
2773 (*D
).Package
.c_str());
2777 * if there are alternatives, we've already picked one, so skip
2780 * TODO: this means that if there's a build-dep on A|B and B is
2781 * installed, we'll still try to install A; more importantly,
2782 * if A is currently broken, we cannot go back and try B. To fix
2783 * this would require we do a Resolve cycle for each package we
2784 * add to the install list. Ugh
2788 * If this is a virtual package, we need to check the list of
2789 * packages that provide it and see if any of those are
2792 pkgCache::PrvIterator Prv
= Pkg
.ProvidesList();
2793 for (; Prv
.end() != true; Prv
++)
2795 if (_config
->FindB("Debug::BuildDeps",false) == true)
2796 cout
<< " Checking provider " << Prv
.OwnerPkg().FullName() << endl
;
2798 if ((*Cache
)[Prv
.OwnerPkg()].InstVerIter(*Cache
).end() == false)
2802 // Get installed version and version we are going to install
2803 pkgCache::VerIterator IV
= (*Cache
)[Pkg
].InstVerIter(*Cache
);
2805 if ((*D
).Version
[0] != '\0') {
2806 // Versioned dependency
2808 pkgCache::VerIterator CV
= (*Cache
)[Pkg
].CandidateVerIter(*Cache
);
2810 for (; CV
.end() != true; CV
++)
2812 if (Cache
->VS().CheckDep(CV
.VerStr(),(*D
).Op
,(*D
).Version
.c_str()) == true)
2815 if (CV
.end() == true)
2817 if (hasAlternatives
)
2823 return _error
->Error(_("%s dependency for %s cannot be satisfied "
2824 "because no available versions of package %s "
2825 "can satisfy version requirements"),
2826 Last
->BuildDepType((*D
).Type
),Src
.c_str(),
2827 (*D
).Package
.c_str());
2833 // Only consider virtual packages if there is no versioned dependency
2834 if (Prv
.end() == false)
2836 if (_config
->FindB("Debug::BuildDeps",false) == true)
2837 cout
<< " Is provided by installed package " << Prv
.OwnerPkg().FullName() << endl
;
2838 skipAlternatives
= hasAlternatives
;
2843 if (IV
.end() == false)
2845 if (_config
->FindB("Debug::BuildDeps",false) == true)
2846 cout
<< " Is installed\n";
2848 if (Cache
->VS().CheckDep(IV
.VerStr(),(*D
).Op
,(*D
).Version
.c_str()) == true)
2850 skipAlternatives
= hasAlternatives
;
2854 if (_config
->FindB("Debug::BuildDeps",false) == true)
2855 cout
<< " ...but the installed version doesn't meet the version requirement\n";
2857 if (((*D
).Op
& pkgCache::Dep::LessEq
) == pkgCache::Dep::LessEq
)
2859 return _error
->Error(_("Failed to satisfy %s dependency for %s: Installed package %s is too new"),
2860 Last
->BuildDepType((*D
).Type
),
2862 Pkg
.FullName(true).c_str());
2867 if (_config
->FindB("Debug::BuildDeps",false) == true)
2868 cout
<< " Trying to install " << (*D
).Package
<< endl
;
2870 if (TryToInstallBuildDep(Pkg
,Cache
,Fix
,false,false) == true)
2872 // We successfully installed something; skip remaining alternatives
2873 skipAlternatives
= hasAlternatives
;
2874 if(_config
->FindB("APT::Get::Build-Dep-Automatic", false) == true)
2875 Cache
->MarkAuto(Pkg
, true);
2878 else if (hasAlternatives
)
2880 if (_config
->FindB("Debug::BuildDeps",false) == true)
2881 cout
<< " Unsatisfiable, trying alternatives\n";
2886 return _error
->Error(_("Failed to satisfy %s dependency for %s: %s"),
2887 Last
->BuildDepType((*D
).Type
),
2889 (*D
).Package
.c_str());
2894 Fix
.InstallProtect();
2895 if (Fix
.Resolve(true) == false)
2898 // Now we check the state of the packages,
2899 if (Cache
->BrokenCount() != 0)
2901 ShowBroken(cout
, Cache
, false);
2902 return _error
->Error(_("Build-dependencies for %s could not be satisfied."),*I
);
2906 if (InstallPackages(Cache
, false, true) == false)
2907 return _error
->Error(_("Failed to process build dependencies"));
2911 // GetChangelogPath - return a path pointing to a changelog file or dir /*{{{*/
2912 // ---------------------------------------------------------------------
2913 /* This returns a "path" string for the changelog url construction.
2914 * Please note that its not complete, it either needs a "/changelog"
2915 * appended (for the packages.debian.org/changelogs site) or a
2916 * ".changelog" (for third party sites that store the changelog in the
2917 * pool/ next to the deb itself)
2918 * Example return: "pool/main/a/apt/apt_0.8.8ubuntu3"
2920 string
GetChangelogPath(CacheFile
&Cache
,
2921 pkgCache::PkgIterator Pkg
,
2922 pkgCache::VerIterator Ver
)
2926 pkgRecords
Recs(Cache
);
2927 pkgRecords::Parser
&rec
=Recs
.Lookup(Ver
.FileList());
2928 string srcpkg
= rec
.SourcePkg().empty() ? Pkg
.Name() : rec
.SourcePkg();
2929 string ver
= Ver
.VerStr();
2930 // if there is a source version it always wins
2931 if (rec
.SourceVer() != "")
2932 ver
= rec
.SourceVer();
2933 path
= flNotFile(rec
.FileName());
2934 path
+= srcpkg
+ "_" + StripEpoch(ver
);
2938 // GuessThirdPartyChangelogUri - return url /*{{{*/
2939 // ---------------------------------------------------------------------
2940 /* Contruct a changelog file path for third party sites that do not use
2941 * packages.debian.org/changelogs
2942 * This simply uses the ArchiveURI() of the source pkg and looks for
2943 * a .changelog file there, Example for "mediabuntu":
2944 * apt-get changelog mplayer-doc:
2945 * http://packages.medibuntu.org/pool/non-free/m/mplayer/mplayer_1.0~rc4~try1.dsfg1-1ubuntu1+medibuntu1.changelog
2947 bool GuessThirdPartyChangelogUri(CacheFile
&Cache
,
2948 pkgCache::PkgIterator Pkg
,
2949 pkgCache::VerIterator Ver
,
2952 // get the binary deb server path
2953 pkgCache::VerFileIterator Vf
= Ver
.FileList();
2954 if (Vf
.end() == true)
2956 pkgCache::PkgFileIterator F
= Vf
.File();
2957 pkgIndexFile
*index
;
2958 pkgSourceList
*SrcList
= Cache
.GetSourceList();
2959 if(SrcList
->FindIndex(F
, index
) == false)
2962 // get archive uri for the binary deb
2963 string path_without_dot_changelog
= GetChangelogPath(Cache
, Pkg
, Ver
);
2964 out_uri
= index
->ArchiveURI(path_without_dot_changelog
+ ".changelog");
2966 // now strip away the filename and add srcpkg_srcver.changelog
2970 // DownloadChangelog - Download the changelog /*{{{*/
2971 // ---------------------------------------------------------------------
2972 bool DownloadChangelog(CacheFile
&CacheFile
, pkgAcquire
&Fetcher
,
2973 pkgCache::VerIterator Ver
, string targetfile
)
2974 /* Download a changelog file for the given package version to
2975 * targetfile. This will first try the server from Apt::Changelogs::Server
2976 * (http://packages.debian.org/changelogs by default) and if that gives
2977 * a 404 tries to get it from the archive directly (see
2978 * GuessThirdPartyChangelogUri for details how)
2984 string changelog_uri
;
2986 // data structures we need
2987 pkgCache::PkgIterator Pkg
= Ver
.ParentPkg();
2989 // make the server root configurable
2990 server
= _config
->Find("Apt::Changelogs::Server",
2991 "http://packages.debian.org/changelogs");
2992 path
= GetChangelogPath(CacheFile
, Pkg
, Ver
);
2993 strprintf(changelog_uri
, "%s/%s/changelog", server
.c_str(), path
.c_str());
2994 if (_config
->FindB("APT::Get::Print-URIs", false) == true)
2996 std::cout
<< '\'' << changelog_uri
<< '\'' << std::endl
;
3000 strprintf(descr
, _("Changelog for %s (%s)"), Pkg
.Name(), changelog_uri
.c_str());
3002 new pkgAcqFile(&Fetcher
, changelog_uri
, "", 0, descr
, Pkg
.Name(), "ignored", targetfile
);
3004 // try downloading it, if that fails, try third-party-changelogs location
3005 // FIXME: Fetcher.Run() is "Continue" even if I get a 404?!?
3007 if (!FileExists(targetfile
))
3009 string third_party_uri
;
3010 if (GuessThirdPartyChangelogUri(CacheFile
, Pkg
, Ver
, third_party_uri
))
3012 strprintf(descr
, _("Changelog for %s (%s)"), Pkg
.Name(), third_party_uri
.c_str());
3013 new pkgAcqFile(&Fetcher
, third_party_uri
, "", 0, descr
, Pkg
.Name(), "ignored", targetfile
);
3018 if (FileExists(targetfile
))
3022 return _error
->Error("changelog download failed");
3025 // DisplayFileInPager - Display File with pager /*{{{*/
3026 void DisplayFileInPager(string filename
)
3028 pid_t Process
= ExecFork();
3031 const char *Args
[3];
3032 Args
[0] = "/usr/bin/sensible-pager";
3033 Args
[1] = filename
.c_str();
3035 execvp(Args
[0],(char **)Args
);
3039 // Wait for the subprocess
3040 ExecWait(Process
, "sensible-pager", false);
3043 // DoChangelog - Get changelog from the command line /*{{{*/
3044 // ---------------------------------------------------------------------
3045 bool DoChangelog(CommandLine
&CmdL
)
3048 if (Cache
.ReadOnlyOpen() == false)
3051 APT::CacheSetHelper
helper(c0out
);
3052 APT::VersionSet verset
= APT::VersionSet::FromCommandLine(Cache
,
3053 CmdL
.FileList
+ 1, APT::VersionSet::CANDIDATE
, helper
);
3054 if (verset
.empty() == true)
3058 if (_config
->FindB("APT::Get::Print-URIs", false) == true)
3059 for (APT::VersionSet::const_iterator Ver
= verset
.begin();
3060 Ver
!= verset
.end(); ++Ver
)
3061 return DownloadChangelog(Cache
, Fetcher
, Ver
, "");
3063 AcqTextStatus
Stat(ScreenWidth
, _config
->FindI("quiet",0));
3064 Fetcher
.Setup(&Stat
);
3066 bool const downOnly
= _config
->FindB("APT::Get::Download-Only", false);
3069 char* tmpdir
= NULL
;
3070 if (downOnly
== false)
3072 const char* const tmpDir
= getenv("TMPDIR");
3073 if (tmpDir
!= NULL
&& *tmpDir
!= '\0')
3074 snprintf(tmpname
, sizeof(tmpname
), "%s/apt-changelog-XXXXXX", tmpDir
);
3076 strncpy(tmpname
, "/tmp/apt-changelog-XXXXXX", sizeof(tmpname
));
3077 tmpdir
= mkdtemp(tmpname
);
3079 return _error
->Errno("mkdtemp", "mkdtemp failed");
3082 for (APT::VersionSet::const_iterator Ver
= verset
.begin();
3083 Ver
!= verset
.end();
3086 string changelogfile
;
3087 if (downOnly
== false)
3088 changelogfile
.append(tmpname
).append("changelog");
3090 changelogfile
.append(Ver
.ParentPkg().Name()).append(".changelog");
3091 if (DownloadChangelog(Cache
, Fetcher
, Ver
, changelogfile
) && downOnly
== false)
3093 DisplayFileInPager(changelogfile
);
3094 // cleanup temp file
3095 unlink(changelogfile
.c_str());
3104 // DoMoo - Never Ask, Never Tell /*{{{*/
3105 // ---------------------------------------------------------------------
3107 bool DoMoo(CommandLine
&CmdL
)
3116 "....\"Have you mooed today?\"...\n";
3121 // ShowHelp - Show a help screen /*{{{*/
3122 // ---------------------------------------------------------------------
3124 bool ShowHelp(CommandLine
&CmdL
)
3126 ioprintf(cout
,_("%s %s for %s compiled on %s %s\n"),PACKAGE
,VERSION
,
3127 COMMON_ARCH
,__DATE__
,__TIME__
);
3129 if (_config
->FindB("version") == true)
3131 cout
<< _("Supported modules:") << endl
;
3133 for (unsigned I
= 0; I
!= pkgVersioningSystem::GlobalListLen
; I
++)
3135 pkgVersioningSystem
*VS
= pkgVersioningSystem::GlobalList
[I
];
3136 if (_system
!= 0 && _system
->VS
== VS
)
3140 cout
<< "Ver: " << VS
->Label
<< endl
;
3142 /* Print out all the packaging systems that will work with
3144 for (unsigned J
= 0; J
!= pkgSystem::GlobalListLen
; J
++)
3146 pkgSystem
*Sys
= pkgSystem::GlobalList
[J
];
3151 if (Sys
->VS
->TestCompatibility(*VS
) == true)
3152 cout
<< "Pkg: " << Sys
->Label
<< " (Priority " << Sys
->Score(*_config
) << ")" << endl
;
3156 for (unsigned I
= 0; I
!= pkgSourceList::Type::GlobalListLen
; I
++)
3158 pkgSourceList::Type
*Type
= pkgSourceList::Type::GlobalList
[I
];
3159 cout
<< " S.L: '" << Type
->Name
<< "' " << Type
->Label
<< endl
;
3162 for (unsigned I
= 0; I
!= pkgIndexFile::Type::GlobalListLen
; I
++)
3164 pkgIndexFile::Type
*Type
= pkgIndexFile::Type::GlobalList
[I
];
3165 cout
<< " Idx: " << Type
->Label
<< endl
;
3172 _("Usage: apt-get [options] command\n"
3173 " apt-get [options] install|remove pkg1 [pkg2 ...]\n"
3174 " apt-get [options] source pkg1 [pkg2 ...]\n"
3176 "apt-get is a simple command line interface for downloading and\n"
3177 "installing packages. The most frequently used commands are update\n"
3181 " update - Retrieve new lists of packages\n"
3182 " upgrade - Perform an upgrade\n"
3183 " install - Install new packages (pkg is libc6 not libc6.deb)\n"
3184 " remove - Remove packages\n"
3185 " autoremove - Remove automatically all unused packages\n"
3186 " purge - Remove packages and config files\n"
3187 " source - Download source archives\n"
3188 " build-dep - Configure build-dependencies for source packages\n"
3189 " dist-upgrade - Distribution upgrade, see apt-get(8)\n"
3190 " dselect-upgrade - Follow dselect selections\n"
3191 " clean - Erase downloaded archive files\n"
3192 " autoclean - Erase old downloaded archive files\n"
3193 " check - Verify that there are no broken dependencies\n"
3194 " changelog - Download and display the changelog for the given package\n"
3195 " download - Download the binary package into the current directory\n"
3198 " -h This help text.\n"
3199 " -q Loggable output - no progress indicator\n"
3200 " -qq No output except for errors\n"
3201 " -d Download only - do NOT install or unpack archives\n"
3202 " -s No-act. Perform ordering simulation\n"
3203 " -y Assume Yes to all queries and do not prompt\n"
3204 " -f Attempt to correct a system with broken dependencies in place\n"
3205 " -m Attempt to continue if archives are unlocatable\n"
3206 " -u Show a list of upgraded packages as well\n"
3207 " -b Build the source package after fetching it\n"
3208 " -V Show verbose version numbers\n"
3209 " -c=? Read this configuration file\n"
3210 " -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
3211 "See the apt-get(8), sources.list(5) and apt.conf(5) manual\n"
3212 "pages for more information and options.\n"
3213 " This APT has Super Cow Powers.\n");
3217 // SigWinch - Window size change signal handler /*{{{*/
3218 // ---------------------------------------------------------------------
3222 // Riped from GNU ls
3226 if (ioctl(1, TIOCGWINSZ
, &ws
) != -1 && ws
.ws_col
>= 5)
3227 ScreenWidth
= ws
.ws_col
- 1;
3231 int main(int argc
,const char *argv
[]) /*{{{*/
3233 CommandLine::Args Args
[] = {
3234 {'h',"help","help",0},
3235 {'v',"version","version",0},
3236 {'V',"verbose-versions","APT::Get::Show-Versions",0},
3237 {'q',"quiet","quiet",CommandLine::IntLevel
},
3238 {'q',"silent","quiet",CommandLine::IntLevel
},
3239 {'d',"download-only","APT::Get::Download-Only",0},
3240 {'b',"compile","APT::Get::Compile",0},
3241 {'b',"build","APT::Get::Compile",0},
3242 {'s',"simulate","APT::Get::Simulate",0},
3243 {'s',"just-print","APT::Get::Simulate",0},
3244 {'s',"recon","APT::Get::Simulate",0},
3245 {'s',"dry-run","APT::Get::Simulate",0},
3246 {'s',"no-act","APT::Get::Simulate",0},
3247 {'y',"yes","APT::Get::Assume-Yes",0},
3248 {'y',"assume-yes","APT::Get::Assume-Yes",0},
3249 {'f',"fix-broken","APT::Get::Fix-Broken",0},
3250 {'u',"show-upgraded","APT::Get::Show-Upgraded",0},
3251 {'m',"ignore-missing","APT::Get::Fix-Missing",0},
3252 {'t',"target-release","APT::Default-Release",CommandLine::HasArg
},
3253 {'t',"default-release","APT::Default-Release",CommandLine::HasArg
},
3254 {0,"download","APT::Get::Download",0},
3255 {0,"fix-missing","APT::Get::Fix-Missing",0},
3256 {0,"ignore-hold","APT::Ignore-Hold",0},
3257 {0,"upgrade","APT::Get::upgrade",0},
3258 {0,"only-upgrade","APT::Get::Only-Upgrade",0},
3259 {0,"force-yes","APT::Get::force-yes",0},
3260 {0,"print-uris","APT::Get::Print-URIs",0},
3261 {0,"diff-only","APT::Get::Diff-Only",0},
3262 {0,"debian-only","APT::Get::Diff-Only",0},
3263 {0,"tar-only","APT::Get::Tar-Only",0},
3264 {0,"dsc-only","APT::Get::Dsc-Only",0},
3265 {0,"purge","APT::Get::Purge",0},
3266 {0,"list-cleanup","APT::Get::List-Cleanup",0},
3267 {0,"reinstall","APT::Get::ReInstall",0},
3268 {0,"trivial-only","APT::Get::Trivial-Only",0},
3269 {0,"remove","APT::Get::Remove",0},
3270 {0,"only-source","APT::Get::Only-Source",0},
3271 {0,"arch-only","APT::Get::Arch-Only",0},
3272 {0,"auto-remove","APT::Get::AutomaticRemove",0},
3273 {0,"allow-unauthenticated","APT::Get::AllowUnauthenticated",0},
3274 {0,"install-recommends","APT::Install-Recommends",CommandLine::Boolean
},
3275 {0,"install-suggests","APT::Install-Suggests",CommandLine::Boolean
},
3276 {0,"fix-policy","APT::Get::Fix-Policy-Broken",0},
3277 {0,"solver","APT::Solver",CommandLine::HasArg
},
3278 {'c',"config-file",0,CommandLine::ConfigFile
},
3279 {'o',"option",0,CommandLine::ArbItem
},
3281 CommandLine::Dispatch Cmds
[] = {{"update",&DoUpdate
},
3282 {"upgrade",&DoUpgrade
},
3283 {"install",&DoInstall
},
3284 {"remove",&DoInstall
},
3285 {"purge",&DoInstall
},
3286 {"autoremove",&DoInstall
},
3287 {"markauto",&DoMarkAuto
},
3288 {"unmarkauto",&DoMarkAuto
},
3289 {"dist-upgrade",&DoDistUpgrade
},
3290 {"dselect-upgrade",&DoDSelectUpgrade
},
3291 {"build-dep",&DoBuildDep
},
3293 {"autoclean",&DoAutoClean
},
3295 {"source",&DoSource
},
3296 {"download",&DoDownload
},
3297 {"changelog",&DoChangelog
},
3302 // Set up gettext support
3303 setlocale(LC_ALL
,"");
3304 textdomain(PACKAGE
);
3306 // Parse the command line and initialize the package library
3307 CommandLine
CmdL(Args
,_config
);
3308 if (pkgInitConfig(*_config
) == false ||
3309 CmdL
.Parse(argc
,argv
) == false ||
3310 pkgInitSystem(*_config
,_system
) == false)
3312 if (_config
->FindB("version") == true)
3315 _error
->DumpErrors();
3319 // See if the help should be shown
3320 if (_config
->FindB("help") == true ||
3321 _config
->FindB("version") == true ||
3322 CmdL
.FileSize() == 0)
3328 // simulate user-friendly if apt-get has no root privileges
3329 if (getuid() != 0 && _config
->FindB("APT::Get::Simulate") == true &&
3330 (CmdL
.FileSize() == 0 ||
3331 (strcmp(CmdL
.FileList
[0], "source") != 0 && strcmp(CmdL
.FileList
[0], "download") != 0 &&
3332 strcmp(CmdL
.FileList
[0], "changelog") != 0)))
3334 if (_config
->FindB("APT::Get::Show-User-Simulation-Note",true) == true)
3335 cout
<< _("NOTE: This is only a simulation!\n"
3336 " apt-get needs root privileges for real execution.\n"
3337 " Keep also in mind that locking is deactivated,\n"
3338 " so don't depend on the relevance to the real current situation!"
3340 _config
->Set("Debug::NoLocking",true);
3343 // Deal with stdout not being a tty
3344 if (!isatty(STDOUT_FILENO
) && _config
->FindI("quiet", -1) == -1)
3345 _config
->Set("quiet","1");
3347 // Setup the output streams
3348 c0out
.rdbuf(cout
.rdbuf());
3349 c1out
.rdbuf(cout
.rdbuf());
3350 c2out
.rdbuf(cout
.rdbuf());
3351 if (_config
->FindI("quiet",0) > 0)
3352 c0out
.rdbuf(devnull
.rdbuf());
3353 if (_config
->FindI("quiet",0) > 1)
3354 c1out
.rdbuf(devnull
.rdbuf());
3356 // Setup the signals
3357 signal(SIGPIPE
,SIG_IGN
);
3358 signal(SIGWINCH
,SigWinch
);
3361 // Match the operation
3362 CmdL
.DispatchArg(Cmds
);
3364 // Print any errors or warnings found during parsing
3365 bool const Errors
= _error
->PendingError();
3366 if (_config
->FindI("quiet",0) > 0)
3367 _error
->DumpErrors();
3369 _error
->DumpErrors(GlobalError::DEBUG
);
3370 return Errors
== true ? 100 : 0;