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 /*{{{*/
30 #include <apt-pkg/aptconfiguration.h>
31 #include <apt-pkg/error.h>
32 #include <apt-pkg/cmndline.h>
33 #include <apt-pkg/init.h>
34 #include <apt-pkg/depcache.h>
35 #include <apt-pkg/sourcelist.h>
36 #include <apt-pkg/algorithms.h>
37 #include <apt-pkg/acquire-item.h>
38 #include <apt-pkg/strutl.h>
39 #include <apt-pkg/fileutl.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>
48 #include <apt-pkg/progress.h>
49 #include <apt-pkg/pkgsystem.h>
50 #include <apt-pkg/pkgrecords.h>
51 #include <apt-pkg/indexfile.h>
53 #include "acqprogress.h"
60 #include <sys/ioctl.h>
62 #include <sys/statfs.h>
63 #include <sys/statvfs.h>
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
;
138 else if (_config
->FindB("APT::Get::Assume-No",false) == true)
140 c1out
<< _("N") << endl
;
144 char response
[1024] = "";
145 cin
.getline(response
, sizeof(response
));
150 if (strlen(response
) == 0)
156 Res
= regcomp(&Pattern
, nl_langinfo(YESEXPR
),
157 REG_EXTENDED
|REG_ICASE
|REG_NOSUB
);
161 regerror(Res
,&Pattern
,Error
,sizeof(Error
));
162 return _error
->Error(_("Regex compilation error - %s"),Error
);
165 Res
= regexec(&Pattern
, response
, 0, NULL
, 0);
171 // AnalPrompt - Annoying Yes No Prompt. /*{{{*/
172 // ---------------------------------------------------------------------
173 /* Returns true on a Yes.*/
174 bool AnalPrompt(const char *Text
)
177 cin
.getline(Buf
,sizeof(Buf
));
178 if (strcmp(Buf
,Text
) == 0)
183 // ShowList - Show a list /*{{{*/
184 // ---------------------------------------------------------------------
185 /* This prints out a string of space separated words with a title and
186 a two space indent line wraped to the current screen width. */
187 bool ShowList(ostream
&out
,string Title
,string List
,string VersionsList
)
189 if (List
.empty() == true)
191 // trim trailing space
192 int NonSpace
= List
.find_last_not_of(' ');
195 List
= List
.erase(NonSpace
+ 1);
196 if (List
.empty() == true)
200 // Acount for the leading space
201 int ScreenWidth
= ::ScreenWidth
- 3;
203 out
<< Title
<< endl
;
204 string::size_type Start
= 0;
205 string::size_type VersionsStart
= 0;
206 while (Start
< List
.size())
208 if(_config
->FindB("APT::Get::Show-Versions",false) == true &&
209 VersionsList
.size() > 0) {
210 string::size_type End
;
211 string::size_type VersionsEnd
;
213 End
= List
.find(' ',Start
);
214 VersionsEnd
= VersionsList
.find('\n', VersionsStart
);
216 out
<< " " << string(List
,Start
,End
- Start
) << " (" <<
217 string(VersionsList
,VersionsStart
,VersionsEnd
- VersionsStart
) <<
220 if (End
== string::npos
|| End
< Start
)
221 End
= Start
+ ScreenWidth
;
224 VersionsStart
= VersionsEnd
+ 1;
226 string::size_type End
;
228 if (Start
+ ScreenWidth
>= List
.size())
231 End
= List
.rfind(' ',Start
+ScreenWidth
);
233 if (End
== string::npos
|| End
< Start
)
234 End
= Start
+ ScreenWidth
;
235 out
<< " " << string(List
,Start
,End
- Start
) << endl
;
243 // ShowBroken - Debugging aide /*{{{*/
244 // ---------------------------------------------------------------------
245 /* This prints out the names of all the packages that are broken along
246 with the name of each each broken dependency and a quite version
249 The output looks like:
250 The following packages have unmet dependencies:
251 exim: Depends: libc6 (>= 2.1.94) but 2.1.3-10 is to be installed
252 Depends: libldap2 (>= 2.0.2-2) but it is not going to be installed
253 Depends: libsasl7 but it is not going to be installed
255 void ShowBroken(ostream
&out
,CacheFile
&Cache
,bool Now
)
257 out
<< _("The following packages have unmet dependencies:") << endl
;
258 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
260 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
264 if (Cache
[I
].NowBroken() == false)
269 if (Cache
[I
].InstBroken() == false)
273 // Print out each package and the failed dependencies
274 out
<< " " << I
.FullName(true) << " :";
275 unsigned const Indent
= I
.FullName(true).size() + 3;
277 pkgCache::VerIterator Ver
;
280 Ver
= I
.CurrentVer();
282 Ver
= Cache
[I
].InstVerIter(Cache
);
284 if (Ver
.end() == true)
290 for (pkgCache::DepIterator D
= Ver
.DependsList(); D
.end() == false;)
292 // Compute a single dependency element (glob or)
293 pkgCache::DepIterator Start
;
294 pkgCache::DepIterator End
;
295 D
.GlobOr(Start
,End
); // advances D
297 if (Cache
->IsImportantDep(End
) == false)
302 if ((Cache
[End
] & pkgDepCache::DepGNow
) == pkgDepCache::DepGNow
)
307 if ((Cache
[End
] & pkgDepCache::DepGInstall
) == pkgDepCache::DepGInstall
)
315 for (unsigned J
= 0; J
!= Indent
; J
++)
319 if (FirstOr
== false)
321 for (unsigned J
= 0; J
!= strlen(End
.DepType()) + 3; J
++)
325 out
<< ' ' << End
.DepType() << ": ";
328 out
<< Start
.TargetPkg().FullName(true);
330 // Show a quick summary of the version requirements
331 if (Start
.TargetVer() != 0)
332 out
<< " (" << Start
.CompType() << " " << Start
.TargetVer() << ")";
334 /* Show a summary of the target package if possible. In the case
335 of virtual packages we show nothing */
336 pkgCache::PkgIterator Targ
= Start
.TargetPkg();
337 if (Targ
->ProvidesList
== 0)
340 pkgCache::VerIterator Ver
= Cache
[Targ
].InstVerIter(Cache
);
342 Ver
= Targ
.CurrentVer();
344 if (Ver
.end() == false)
347 ioprintf(out
,_("but %s is installed"),Ver
.VerStr());
349 ioprintf(out
,_("but %s is to be installed"),Ver
.VerStr());
353 if (Cache
[Targ
].CandidateVerIter(Cache
).end() == true)
355 if (Targ
->ProvidesList
== 0)
356 out
<< _("but it is not installable");
358 out
<< _("but it is a virtual package");
361 out
<< (Now
?_("but it is not installed"):_("but it is not going to be installed"));
377 // ShowNew - Show packages to newly install /*{{{*/
378 // ---------------------------------------------------------------------
380 void ShowNew(ostream
&out
,CacheFile
&Cache
)
382 /* Print out a list of packages that are going to be installed extra
383 to what the user asked */
386 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
388 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
389 if (Cache
[I
].NewInstall() == true) {
390 List
+= I
.FullName(true) + " ";
391 VersionsList
+= string(Cache
[I
].CandVersion
) + "\n";
395 ShowList(out
,_("The following NEW packages will be installed:"),List
,VersionsList
);
398 // ShowDel - Show packages to delete /*{{{*/
399 // ---------------------------------------------------------------------
401 void ShowDel(ostream
&out
,CacheFile
&Cache
)
403 /* Print out a list of packages that are going to be removed extra
404 to what the user asked */
407 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
409 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
410 if (Cache
[I
].Delete() == true)
412 if ((Cache
[I
].iFlags
& pkgDepCache::Purge
) == pkgDepCache::Purge
)
413 List
+= I
.FullName(true) + "* ";
415 List
+= I
.FullName(true) + " ";
417 VersionsList
+= string(Cache
[I
].CandVersion
)+ "\n";
421 ShowList(out
,_("The following packages will be REMOVED:"),List
,VersionsList
);
424 // ShowKept - Show kept packages /*{{{*/
425 // ---------------------------------------------------------------------
427 void ShowKept(ostream
&out
,CacheFile
&Cache
)
431 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
433 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
436 if (Cache
[I
].Upgrade() == true || Cache
[I
].Upgradable() == false ||
437 I
->CurrentVer
== 0 || Cache
[I
].Delete() == true)
440 List
+= I
.FullName(true) + " ";
441 VersionsList
+= string(Cache
[I
].CurVersion
) + " => " + Cache
[I
].CandVersion
+ "\n";
443 ShowList(out
,_("The following packages have been kept back:"),List
,VersionsList
);
446 // ShowUpgraded - Show upgraded packages /*{{{*/
447 // ---------------------------------------------------------------------
449 void ShowUpgraded(ostream
&out
,CacheFile
&Cache
)
453 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
455 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
458 if (Cache
[I
].Upgrade() == false || Cache
[I
].NewInstall() == true)
461 List
+= I
.FullName(true) + " ";
462 VersionsList
+= string(Cache
[I
].CurVersion
) + " => " + Cache
[I
].CandVersion
+ "\n";
464 ShowList(out
,_("The following packages will be upgraded:"),List
,VersionsList
);
467 // ShowDowngraded - Show downgraded packages /*{{{*/
468 // ---------------------------------------------------------------------
470 bool ShowDowngraded(ostream
&out
,CacheFile
&Cache
)
474 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
476 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
479 if (Cache
[I
].Downgrade() == false || Cache
[I
].NewInstall() == true)
482 List
+= I
.FullName(true) + " ";
483 VersionsList
+= string(Cache
[I
].CurVersion
) + " => " + Cache
[I
].CandVersion
+ "\n";
485 return ShowList(out
,_("The following packages will be DOWNGRADED:"),List
,VersionsList
);
488 // ShowHold - Show held but changed packages /*{{{*/
489 // ---------------------------------------------------------------------
491 bool ShowHold(ostream
&out
,CacheFile
&Cache
)
495 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
497 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
498 if (Cache
[I
].InstallVer
!= (pkgCache::Version
*)I
.CurrentVer() &&
499 I
->SelectedState
== pkgCache::State::Hold
) {
500 List
+= I
.FullName(true) + " ";
501 VersionsList
+= string(Cache
[I
].CurVersion
) + " => " + Cache
[I
].CandVersion
+ "\n";
505 return ShowList(out
,_("The following held packages will be changed:"),List
,VersionsList
);
508 // ShowEssential - Show an essential package warning /*{{{*/
509 // ---------------------------------------------------------------------
510 /* This prints out a warning message that is not to be ignored. It shows
511 all essential packages and their dependents that are to be removed.
512 It is insanely risky to remove the dependents of an essential package! */
513 bool ShowEssential(ostream
&out
,CacheFile
&Cache
)
517 bool *Added
= new bool[Cache
->Head().PackageCount
];
518 for (unsigned int I
= 0; I
!= Cache
->Head().PackageCount
; I
++)
521 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
523 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
524 if ((I
->Flags
& pkgCache::Flag::Essential
) != pkgCache::Flag::Essential
&&
525 (I
->Flags
& pkgCache::Flag::Important
) != pkgCache::Flag::Important
)
528 // The essential package is being removed
529 if (Cache
[I
].Delete() == true)
531 if (Added
[I
->ID
] == false)
534 List
+= I
.FullName(true) + " ";
535 //VersionsList += string(Cache[I].CurVersion) + "\n"; ???
541 if (I
->CurrentVer
== 0)
544 // Print out any essential package depenendents that are to be removed
545 for (pkgCache::DepIterator D
= I
.CurrentVer().DependsList(); D
.end() == false; ++D
)
547 // Skip everything but depends
548 if (D
->Type
!= pkgCache::Dep::PreDepends
&&
549 D
->Type
!= pkgCache::Dep::Depends
)
552 pkgCache::PkgIterator P
= D
.SmartTargetPkg();
553 if (Cache
[P
].Delete() == true)
555 if (Added
[P
->ID
] == true)
560 snprintf(S
,sizeof(S
),_("%s (due to %s) "),P
.FullName(true).c_str(),I
.FullName(true).c_str());
562 //VersionsList += "\n"; ???
568 return ShowList(out
,_("WARNING: The following essential packages will be removed.\n"
569 "This should NOT be done unless you know exactly what you are doing!"),List
,VersionsList
);
573 // Stats - Show some statistics /*{{{*/
574 // ---------------------------------------------------------------------
576 void Stats(ostream
&out
,pkgDepCache
&Dep
)
578 unsigned long Upgrade
= 0;
579 unsigned long Downgrade
= 0;
580 unsigned long Install
= 0;
581 unsigned long ReInstall
= 0;
582 for (pkgCache::PkgIterator I
= Dep
.PkgBegin(); I
.end() == false; ++I
)
584 if (Dep
[I
].NewInstall() == true)
588 if (Dep
[I
].Upgrade() == true)
591 if (Dep
[I
].Downgrade() == true)
595 if (Dep
[I
].Delete() == false && (Dep
[I
].iFlags
& pkgDepCache::ReInstall
) == pkgDepCache::ReInstall
)
599 ioprintf(out
,_("%lu upgraded, %lu newly installed, "),
603 ioprintf(out
,_("%lu reinstalled, "),ReInstall
);
605 ioprintf(out
,_("%lu downgraded, "),Downgrade
);
607 ioprintf(out
,_("%lu to remove and %lu not upgraded.\n"),
608 Dep
.DelCount(),Dep
.KeepCount());
610 if (Dep
.BadCount() != 0)
611 ioprintf(out
,_("%lu not fully installed or removed.\n"),
615 // CacheSetHelperAPTGet - responsible for message telling from the CacheSets/*{{{*/
616 class CacheSetHelperAPTGet
: public APT::CacheSetHelper
{
617 /** \brief stream message should be printed to */
619 /** \brief were things like Task or RegEx used to select packages? */
620 bool explicitlyNamed
;
622 APT::PackageSet virtualPkgs
;
625 std::list
<std::pair
<pkgCache::VerIterator
, std::string
> > selectedByRelease
;
627 CacheSetHelperAPTGet(std::ostream
&out
) : APT::CacheSetHelper(true), out(out
) {
628 explicitlyNamed
= true;
631 virtual void showTaskSelection(pkgCache::PkgIterator
const &Pkg
, string
const &pattern
) {
632 ioprintf(out
, _("Note, selecting '%s' for task '%s'\n"),
633 Pkg
.FullName(true).c_str(), pattern
.c_str());
634 explicitlyNamed
= false;
636 virtual void showRegExSelection(pkgCache::PkgIterator
const &Pkg
, string
const &pattern
) {
637 ioprintf(out
, _("Note, selecting '%s' for regex '%s'\n"),
638 Pkg
.FullName(true).c_str(), pattern
.c_str());
639 explicitlyNamed
= false;
641 virtual void showSelectedVersion(pkgCache::PkgIterator
const &Pkg
, pkgCache::VerIterator
const Ver
,
642 string
const &ver
, bool const verIsRel
) {
643 if (ver
== Ver
.VerStr())
645 selectedByRelease
.push_back(make_pair(Ver
, ver
));
648 bool showVirtualPackageErrors(pkgCacheFile
&Cache
) {
649 if (virtualPkgs
.empty() == true)
651 for (APT::PackageSet::const_iterator Pkg
= virtualPkgs
.begin();
652 Pkg
!= virtualPkgs
.end(); ++Pkg
) {
653 if (Pkg
->ProvidesList
!= 0) {
654 ioprintf(c1out
,_("Package %s is a virtual package provided by:\n"),
655 Pkg
.FullName(true).c_str());
657 pkgCache::PrvIterator I
= Pkg
.ProvidesList();
658 unsigned short provider
= 0;
659 for (; I
.end() == false; ++I
) {
660 pkgCache::PkgIterator Pkg
= I
.OwnerPkg();
662 if (Cache
[Pkg
].CandidateVerIter(Cache
) == I
.OwnerVer()) {
663 c1out
<< " " << Pkg
.FullName(true) << " " << I
.OwnerVer().VerStr();
664 if (Cache
[Pkg
].Install() == true && Cache
[Pkg
].NewInstall() == false)
665 c1out
<< _(" [Installed]");
670 // if we found no candidate which provide this package, show non-candidates
672 for (I
= Pkg
.ProvidesList(); I
.end() == false; ++I
)
673 c1out
<< " " << I
.OwnerPkg().FullName(true) << " " << I
.OwnerVer().VerStr()
674 << _(" [Not candidate version]") << endl
;
676 out
<< _("You should explicitly select one to install.") << endl
;
679 _("Package %s is not available, but is referred to by another package.\n"
680 "This may mean that the package is missing, has been obsoleted, or\n"
681 "is only available from another source\n"),Pkg
.FullName(true).c_str());
685 SPtrArray
<bool> Seen
= new bool[Cache
.GetPkgCache()->Head().PackageCount
];
686 memset(Seen
,0,Cache
.GetPkgCache()->Head().PackageCount
*sizeof(*Seen
));
687 for (pkgCache::DepIterator Dep
= Pkg
.RevDependsList();
688 Dep
.end() == false; ++Dep
) {
689 if (Dep
->Type
!= pkgCache::Dep::Replaces
)
691 if (Seen
[Dep
.ParentPkg()->ID
] == true)
693 Seen
[Dep
.ParentPkg()->ID
] = true;
694 List
+= Dep
.ParentPkg().FullName(true) + " ";
695 //VersionsList += string(Dep.ParentPkg().CurVersion) + "\n"; ???
697 ShowList(c1out
,_("However the following packages replace it:"),List
,VersionsList
);
704 virtual pkgCache::VerIterator
canNotFindCandidateVer(pkgCacheFile
&Cache
, pkgCache::PkgIterator
const &Pkg
) {
705 APT::VersionSet
const verset
= tryVirtualPackage(Cache
, Pkg
, APT::VersionSet::CANDIDATE
);
706 if (verset
.empty() == false)
707 return *(verset
.begin());
708 else if (ShowError
== true) {
709 _error
->Error(_("Package '%s' has no installation candidate"),Pkg
.FullName(true).c_str());
710 virtualPkgs
.insert(Pkg
);
712 return pkgCache::VerIterator(Cache
, 0);
715 virtual pkgCache::VerIterator
canNotFindNewestVer(pkgCacheFile
&Cache
, pkgCache::PkgIterator
const &Pkg
) {
716 APT::VersionSet
const verset
= tryVirtualPackage(Cache
, Pkg
, APT::VersionSet::NEWEST
);
717 if (verset
.empty() == false)
718 return *(verset
.begin());
719 if (ShowError
== true)
720 ioprintf(out
, _("Virtual packages like '%s' can't be removed\n"), Pkg
.FullName(true).c_str());
721 return pkgCache::VerIterator(Cache
, 0);
724 APT::VersionSet
tryVirtualPackage(pkgCacheFile
&Cache
, pkgCache::PkgIterator
const &Pkg
,
725 APT::VersionSet::Version
const &select
) {
726 /* This is a pure virtual package and there is a single available
727 candidate providing it. */
728 if (unlikely(Cache
[Pkg
].CandidateVer
!= 0) || Pkg
->ProvidesList
== 0)
729 return APT::VersionSet();
731 pkgCache::PkgIterator Prov
;
732 bool found_one
= false;
733 for (pkgCache::PrvIterator P
= Pkg
.ProvidesList(); P
; ++P
) {
734 pkgCache::VerIterator
const PVer
= P
.OwnerVer();
735 pkgCache::PkgIterator
const PPkg
= PVer
.ParentPkg();
737 /* Ignore versions that are not a candidate. */
738 if (Cache
[PPkg
].CandidateVer
!= PVer
)
741 if (found_one
== false) {
744 } else if (PPkg
!= Prov
) {
745 // same group, so it's a foreign package
746 if (PPkg
->Group
== Prov
->Group
) {
747 // do we already have the requested arch?
748 if (strcmp(Pkg
.Arch(), Prov
.Arch()) == 0 ||
749 strcmp(Prov
.Arch(), "all") == 0 ||
750 unlikely(strcmp(PPkg
.Arch(), Prov
.Arch()) == 0)) // packages have only on candidate, but just to be sure
752 // see which architecture we prefer more and switch to it
753 std::vector
<std::string
> archs
= APT::Configuration::getArchitectures();
754 if (std::find(archs
.begin(), archs
.end(), PPkg
.Arch()) < std::find(archs
.begin(), archs
.end(), Prov
.Arch()))
758 found_one
= false; // we found at least two
763 if (found_one
== true) {
764 ioprintf(out
, _("Note, selecting '%s' instead of '%s'\n"),
765 Prov
.FullName(true).c_str(), Pkg
.FullName(true).c_str());
766 return APT::VersionSet::FromPackage(Cache
, Prov
, select
, *this);
768 return APT::VersionSet();
771 inline bool allPkgNamedExplicitly() const { return explicitlyNamed
; }
775 // TryToInstall - Mark a package for installation /*{{{*/
776 struct TryToInstall
{
778 pkgProblemResolver
* Fix
;
780 unsigned long AutoMarkChanged
;
781 APT::PackageSet doAutoInstallLater
;
783 TryToInstall(pkgCacheFile
&Cache
, pkgProblemResolver
*PM
, bool const FixBroken
) : Cache(&Cache
), Fix(PM
),
784 FixBroken(FixBroken
), AutoMarkChanged(0) {};
786 void operator() (pkgCache::VerIterator
const &Ver
) {
787 pkgCache::PkgIterator Pkg
= Ver
.ParentPkg();
789 Cache
->GetDepCache()->SetCandidateVersion(Ver
);
790 pkgDepCache::StateCache
&State
= (*Cache
)[Pkg
];
792 // Handle the no-upgrade case
793 if (_config
->FindB("APT::Get::upgrade",true) == false && Pkg
->CurrentVer
!= 0)
794 ioprintf(c1out
,_("Skipping %s, it is already installed and upgrade is not set.\n"),
795 Pkg
.FullName(true).c_str());
796 // Ignore request for install if package would be new
797 else if (_config
->FindB("APT::Get::Only-Upgrade", false) == true && Pkg
->CurrentVer
== 0)
798 ioprintf(c1out
,_("Skipping %s, it is not installed and only upgrades are requested.\n"),
799 Pkg
.FullName(true).c_str());
805 Cache
->GetDepCache()->MarkInstall(Pkg
,false);
807 if (State
.Install() == false) {
808 if (_config
->FindB("APT::Get::ReInstall",false) == true) {
809 if (Pkg
->CurrentVer
== 0 || Pkg
.CurrentVer().Downloadable() == false)
810 ioprintf(c1out
,_("Reinstallation of %s is not possible, it cannot be downloaded.\n"),
811 Pkg
.FullName(true).c_str());
813 Cache
->GetDepCache()->SetReInstall(Pkg
, true);
815 ioprintf(c1out
,_("%s is already the newest version.\n"),
816 Pkg
.FullName(true).c_str());
819 // Install it with autoinstalling enabled (if we not respect the minial
820 // required deps or the policy)
821 if (FixBroken
== false)
822 doAutoInstallLater
.insert(Pkg
);
825 // see if we need to fix the auto-mark flag
826 // e.g. apt-get install foo
827 // where foo is marked automatic
828 if (State
.Install() == false &&
829 (State
.Flags
& pkgCache::Flag::Auto
) &&
830 _config
->FindB("APT::Get::ReInstall",false) == false &&
831 _config
->FindB("APT::Get::Only-Upgrade",false) == false &&
832 _config
->FindB("APT::Get::Download-Only",false) == false)
834 ioprintf(c1out
,_("%s set to manually installed.\n"),
835 Pkg
.FullName(true).c_str());
836 Cache
->GetDepCache()->MarkAuto(Pkg
,false);
841 bool propergateReleaseCandiateSwitching(std::list
<std::pair
<pkgCache::VerIterator
, std::string
> > start
, std::ostream
&out
)
843 for (std::list
<std::pair
<pkgCache::VerIterator
, std::string
> >::const_iterator s
= start
.begin();
844 s
!= start
.end(); ++s
)
845 Cache
->GetDepCache()->SetCandidateVersion(s
->first
);
848 std::list
<std::pair
<pkgCache::VerIterator
, pkgCache::VerIterator
> > Changed
;
849 for (std::list
<std::pair
<pkgCache::VerIterator
, std::string
> >::const_iterator s
= start
.begin();
850 s
!= start
.end(); ++s
)
852 Changed
.push_back(std::make_pair(s
->first
, pkgCache::VerIterator(*Cache
)));
853 // We continue here even if it failed to enhance the ShowBroken output
854 Success
&= Cache
->GetDepCache()->SetCandidateRelease(s
->first
, s
->second
, Changed
);
856 for (std::list
<std::pair
<pkgCache::VerIterator
, pkgCache::VerIterator
> >::const_iterator c
= Changed
.begin();
857 c
!= Changed
.end(); ++c
)
859 if (c
->second
.end() == true)
860 ioprintf(out
, _("Selected version '%s' (%s) for '%s'\n"),
861 c
->first
.VerStr(), c
->first
.RelStr().c_str(), c
->first
.ParentPkg().FullName(true).c_str());
862 else if (c
->first
.ParentPkg()->Group
!= c
->second
.ParentPkg()->Group
)
864 pkgCache::VerIterator V
= (*Cache
)[c
->first
.ParentPkg()].CandidateVerIter(*Cache
);
865 ioprintf(out
, _("Selected version '%s' (%s) for '%s' because of '%s'\n"), V
.VerStr(),
866 V
.RelStr().c_str(), V
.ParentPkg().FullName(true).c_str(), c
->second
.ParentPkg().FullName(true).c_str());
872 void doAutoInstall() {
873 for (APT::PackageSet::const_iterator P
= doAutoInstallLater
.begin();
874 P
!= doAutoInstallLater
.end(); ++P
) {
875 pkgDepCache::StateCache
&State
= (*Cache
)[P
];
876 if (State
.InstBroken() == false && State
.InstPolicyBroken() == false)
878 Cache
->GetDepCache()->MarkInstall(P
, true);
880 doAutoInstallLater
.clear();
884 // TryToRemove - Mark a package for removal /*{{{*/
887 pkgProblemResolver
* Fix
;
890 TryToRemove(pkgCacheFile
&Cache
, pkgProblemResolver
*PM
) : Cache(&Cache
), Fix(PM
),
891 PurgePkgs(_config
->FindB("APT::Get::Purge", false)) {};
893 void operator() (pkgCache::VerIterator
const &Ver
)
895 pkgCache::PkgIterator Pkg
= Ver
.ParentPkg();
904 if ((Pkg
->CurrentVer
== 0 && PurgePkgs
== false) ||
905 (PurgePkgs
== true && Pkg
->CurrentState
== pkgCache::State::NotInstalled
))
907 pkgCache::GrpIterator Grp
= Pkg
.Group();
908 pkgCache::PkgIterator P
= Grp
.PackageList();
909 for (; P
.end() != true; P
= Grp
.NextPkg(P
))
913 if (P
->CurrentVer
!= 0 || (PurgePkgs
== true && P
->CurrentState
!= pkgCache::State::NotInstalled
))
915 // TRANSLATORS: Note, this is not an interactive question
916 ioprintf(c1out
,_("Package '%s' is not installed, so not removed. Did you mean '%s'?\n"),
917 Pkg
.FullName(true).c_str(), P
.FullName(true).c_str());
922 ioprintf(c1out
,_("Package '%s' is not installed, so not removed\n"),Pkg
.FullName(true).c_str());
924 // MarkInstall refuses to install packages on hold
925 Pkg
->SelectedState
= pkgCache::State::Hold
;
928 Cache
->GetDepCache()->MarkDelete(Pkg
, PurgePkgs
);
932 // CacheFile::NameComp - QSort compare by name /*{{{*/
933 // ---------------------------------------------------------------------
935 pkgCache
*CacheFile::SortCache
= 0;
936 int CacheFile::NameComp(const void *a
,const void *b
)
938 if (*(pkgCache::Package
**)a
== 0 || *(pkgCache::Package
**)b
== 0)
939 return *(pkgCache::Package
**)a
- *(pkgCache::Package
**)b
;
941 const pkgCache::Package
&A
= **(pkgCache::Package
**)a
;
942 const pkgCache::Package
&B
= **(pkgCache::Package
**)b
;
944 return strcmp(SortCache
->StrP
+ A
.Name
,SortCache
->StrP
+ B
.Name
);
947 // CacheFile::Sort - Sort by name /*{{{*/
948 // ---------------------------------------------------------------------
950 void CacheFile::Sort()
953 List
= new pkgCache::Package
*[Cache
->Head().PackageCount
];
954 memset(List
,0,sizeof(*List
)*Cache
->Head().PackageCount
);
955 pkgCache::PkgIterator I
= Cache
->PkgBegin();
956 for (;I
.end() != true; ++I
)
960 qsort(List
,Cache
->Head().PackageCount
,sizeof(*List
),NameComp
);
963 // CacheFile::CheckDeps - Open the cache file /*{{{*/
964 // ---------------------------------------------------------------------
965 /* This routine generates the caches and then opens the dependency cache
966 and verifies that the system is OK. */
967 bool CacheFile::CheckDeps(bool AllowBroken
)
969 bool FixBroken
= _config
->FindB("APT::Get::Fix-Broken",false);
971 if (_error
->PendingError() == true)
974 // Check that the system is OK
975 if (DCache
->DelCount() != 0 || DCache
->InstCount() != 0)
976 return _error
->Error("Internal error, non-zero counts");
978 // Apply corrections for half-installed packages
979 if (pkgApplyStatus(*DCache
) == false)
982 if (_config
->FindB("APT::Get::Fix-Policy-Broken",false) == true)
985 if ((DCache
->PolicyBrokenCount() > 0))
987 // upgrade all policy-broken packages with ForceImportantDeps=True
988 for (pkgCache::PkgIterator I
= Cache
->PkgBegin(); !I
.end(); ++I
)
989 if ((*DCache
)[I
].NowPolicyBroken() == true)
990 DCache
->MarkInstall(I
,true,0, false, true);
995 if (DCache
->BrokenCount() == 0 || AllowBroken
== true)
998 // Attempt to fix broken things
999 if (FixBroken
== true)
1001 c1out
<< _("Correcting dependencies...") << flush
;
1002 if (pkgFixBroken(*DCache
) == false || DCache
->BrokenCount() != 0)
1004 c1out
<< _(" failed.") << endl
;
1005 ShowBroken(c1out
,*this,true);
1007 return _error
->Error(_("Unable to correct dependencies"));
1009 if (pkgMinimizeUpgrade(*DCache
) == false)
1010 return _error
->Error(_("Unable to minimize the upgrade set"));
1012 c1out
<< _(" Done") << endl
;
1016 c1out
<< _("You might want to run 'apt-get -f install' to correct these.") << endl
;
1017 ShowBroken(c1out
,*this,true);
1019 return _error
->Error(_("Unmet dependencies. Try using -f."));
1025 // CheckAuth - check if each download comes form a trusted source /*{{{*/
1026 // ---------------------------------------------------------------------
1028 static bool CheckAuth(pkgAcquire
& Fetcher
)
1030 string UntrustedList
;
1031 for (pkgAcquire::ItemIterator I
= Fetcher
.ItemsBegin(); I
< Fetcher
.ItemsEnd(); ++I
)
1033 if (!(*I
)->IsTrusted())
1035 UntrustedList
+= string((*I
)->ShortDesc()) + " ";
1039 if (UntrustedList
== "")
1044 ShowList(c2out
,_("WARNING: The following packages cannot be authenticated!"),UntrustedList
,"");
1046 if (_config
->FindB("APT::Get::AllowUnauthenticated",false) == true)
1048 c2out
<< _("Authentication warning overridden.\n");
1052 if (_config
->FindI("quiet",0) < 2
1053 && _config
->FindB("APT::Get::Assume-Yes",false) == false)
1055 c2out
<< _("Install these packages without verification [y/N]? ") << flush
;
1056 if (!YnPrompt(false))
1057 return _error
->Error(_("Some packages could not be authenticated"));
1061 else if (_config
->FindB("APT::Get::Force-Yes",false) == true)
1066 return _error
->Error(_("There are problems and -y was used without --force-yes"));
1069 // InstallPackages - Actually download and install the packages /*{{{*/
1070 // ---------------------------------------------------------------------
1071 /* This displays the informative messages describing what is going to
1072 happen and then calls the download routines */
1073 bool InstallPackages(CacheFile
&Cache
,bool ShwKept
,bool Ask
= true,
1076 if (_config
->FindB("APT::Get::Purge",false) == true)
1078 pkgCache::PkgIterator I
= Cache
->PkgBegin();
1079 for (; I
.end() == false; ++I
)
1081 if (I
.Purge() == false && Cache
[I
].Mode
== pkgDepCache::ModeDelete
)
1082 Cache
->MarkDelete(I
,true);
1087 bool Essential
= false;
1089 // Show all the various warning indicators
1090 ShowDel(c1out
,Cache
);
1091 ShowNew(c1out
,Cache
);
1092 if (ShwKept
== true)
1093 ShowKept(c1out
,Cache
);
1094 Fail
|= !ShowHold(c1out
,Cache
);
1095 if (_config
->FindB("APT::Get::Show-Upgraded",true) == true)
1096 ShowUpgraded(c1out
,Cache
);
1097 Fail
|= !ShowDowngraded(c1out
,Cache
);
1098 if (_config
->FindB("APT::Get::Download-Only",false) == false)
1099 Essential
= !ShowEssential(c1out
,Cache
);
1104 if (Cache
->BrokenCount() != 0)
1106 ShowBroken(c1out
,Cache
,false);
1107 return _error
->Error(_("Internal error, InstallPackages was called with broken packages!"));
1110 if (Cache
->DelCount() == 0 && Cache
->InstCount() == 0 &&
1111 Cache
->BadCount() == 0)
1115 if (Cache
->DelCount() != 0 && _config
->FindB("APT::Get::Remove",true) == false)
1116 return _error
->Error(_("Packages need to be removed but remove is disabled."));
1118 // Run the simulator ..
1119 if (_config
->FindB("APT::Get::Simulate") == true)
1121 pkgSimulate
PM(Cache
);
1122 int status_fd
= _config
->FindI("APT::Status-Fd",-1);
1123 pkgPackageManager::OrderResult Res
= PM
.DoInstall(status_fd
);
1124 if (Res
== pkgPackageManager::Failed
)
1126 if (Res
!= pkgPackageManager::Completed
)
1127 return _error
->Error(_("Internal error, Ordering didn't finish"));
1131 // Create the text record parser
1132 pkgRecords
Recs(Cache
);
1133 if (_error
->PendingError() == true)
1136 // Create the download object
1138 AcqTextStatus
Stat(ScreenWidth
,_config
->FindI("quiet",0));
1139 if (_config
->FindB("APT::Get::Print-URIs", false) == true)
1141 // force a hashsum for compatibility reasons
1142 _config
->CndSet("Acquire::ForceHash", "md5sum");
1144 else if (Fetcher
.Setup(&Stat
, _config
->FindDir("Dir::Cache::Archives")) == false)
1147 // Read the source list
1148 if (Cache
.BuildSourceList() == false)
1150 pkgSourceList
*List
= Cache
.GetSourceList();
1152 // Create the package manager and prepare to download
1153 SPtr
<pkgPackageManager
> PM
= _system
->CreatePM(Cache
);
1154 if (PM
->GetArchives(&Fetcher
,List
,&Recs
) == false ||
1155 _error
->PendingError() == true)
1158 // Display statistics
1159 unsigned long long FetchBytes
= Fetcher
.FetchNeeded();
1160 unsigned long long FetchPBytes
= Fetcher
.PartialPresent();
1161 unsigned long long DebBytes
= Fetcher
.TotalNeeded();
1162 if (DebBytes
!= Cache
->DebSize())
1164 c0out
<< DebBytes
<< ',' << Cache
->DebSize() << endl
;
1165 c0out
<< _("How odd.. The sizes didn't match, email apt@packages.debian.org") << endl
;
1169 if (DebBytes
!= FetchBytes
)
1170 //TRANSLATOR: The required space between number and unit is already included
1171 // in the replacement strings, so %sB will be correctly translate in e.g. 1,5 MB
1172 ioprintf(c1out
,_("Need to get %sB/%sB of archives.\n"),
1173 SizeToStr(FetchBytes
).c_str(),SizeToStr(DebBytes
).c_str());
1174 else if (DebBytes
!= 0)
1175 //TRANSLATOR: The required space between number and unit is already included
1176 // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
1177 ioprintf(c1out
,_("Need to get %sB of archives.\n"),
1178 SizeToStr(DebBytes
).c_str());
1181 if (Cache
->UsrSize() >= 0)
1182 //TRANSLATOR: The required space between number and unit is already included
1183 // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
1184 ioprintf(c1out
,_("After this operation, %sB of additional disk space will be used.\n"),
1185 SizeToStr(Cache
->UsrSize()).c_str());
1187 //TRANSLATOR: The required space between number and unit is already included
1188 // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
1189 ioprintf(c1out
,_("After this operation, %sB disk space will be freed.\n"),
1190 SizeToStr(-1*Cache
->UsrSize()).c_str());
1192 if (_error
->PendingError() == true)
1195 /* Check for enough free space, but only if we are actually going to
1197 if (_config
->FindB("APT::Get::Print-URIs") == false &&
1198 _config
->FindB("APT::Get::Download",true) == true)
1201 string OutputDir
= _config
->FindDir("Dir::Cache::Archives");
1202 if (statvfs(OutputDir
.c_str(),&Buf
) != 0) {
1203 if (errno
== EOVERFLOW
)
1204 return _error
->WarningE("statvfs",_("Couldn't determine free space in %s"),
1207 return _error
->Errno("statvfs",_("Couldn't determine free space in %s"),
1209 } else if (unsigned(Buf
.f_bfree
) < (FetchBytes
- FetchPBytes
)/Buf
.f_bsize
)
1212 if (statfs(OutputDir
.c_str(),&Stat
) != 0
1213 #if HAVE_STRUCT_STATFS_F_TYPE
1214 || unsigned(Stat
.f_type
) != RAMFS_MAGIC
1217 return _error
->Error(_("You don't have enough free space in %s."),
1223 if (_config
->FindI("quiet",0) >= 2 ||
1224 _config
->FindB("APT::Get::Assume-Yes",false) == true)
1226 if (Fail
== true && _config
->FindB("APT::Get::Force-Yes",false) == false)
1227 return _error
->Error(_("There are problems and -y was used without --force-yes"));
1230 if (Essential
== true && Safety
== true)
1232 if (_config
->FindB("APT::Get::Trivial-Only",false) == true)
1233 return _error
->Error(_("Trivial Only specified but this is not a trivial operation."));
1235 const char *Prompt
= _("Yes, do as I say!");
1237 _("You are about to do something potentially harmful.\n"
1238 "To continue type in the phrase '%s'\n"
1241 if (AnalPrompt(Prompt
) == false)
1243 c2out
<< _("Abort.") << endl
;
1249 // Prompt to continue
1250 if (Ask
== true || Fail
== true)
1252 if (_config
->FindB("APT::Get::Trivial-Only",false) == true)
1253 return _error
->Error(_("Trivial Only specified but this is not a trivial operation."));
1255 if (_config
->FindI("quiet",0) < 2 &&
1256 _config
->FindB("APT::Get::Assume-Yes",false) == false)
1258 c2out
<< _("Do you want to continue [Y/n]? ") << flush
;
1260 if (YnPrompt() == false)
1262 c2out
<< _("Abort.") << endl
;
1269 // Just print out the uris an exit if the --print-uris flag was used
1270 if (_config
->FindB("APT::Get::Print-URIs") == true)
1272 pkgAcquire::UriIterator I
= Fetcher
.UriBegin();
1273 for (; I
!= Fetcher
.UriEnd(); ++I
)
1274 cout
<< '\'' << I
->URI
<< "' " << flNotDir(I
->Owner
->DestFile
) << ' ' <<
1275 I
->Owner
->FileSize
<< ' ' << I
->Owner
->HashSum() << endl
;
1279 if (!CheckAuth(Fetcher
))
1282 /* Unlock the dpkg lock if we are not going to be doing an install
1284 if (_config
->FindB("APT::Get::Download-Only",false) == true)
1290 bool Transient
= false;
1291 if (_config
->FindB("APT::Get::Download",true) == false)
1293 for (pkgAcquire::ItemIterator I
= Fetcher
.ItemsBegin(); I
< Fetcher
.ItemsEnd();)
1295 if ((*I
)->Local
== true)
1301 // Close the item and check if it was found in cache
1303 if ((*I
)->Complete
== false)
1306 // Clear it out of the fetch list
1308 I
= Fetcher
.ItemsBegin();
1312 if (Fetcher
.Run() == pkgAcquire::Failed
)
1316 bool Failed
= false;
1317 for (pkgAcquire::ItemIterator I
= Fetcher
.ItemsBegin(); I
!= Fetcher
.ItemsEnd(); ++I
)
1319 if ((*I
)->Status
== pkgAcquire::Item::StatDone
&&
1320 (*I
)->Complete
== true)
1323 if ((*I
)->Status
== pkgAcquire::Item::StatIdle
)
1330 fprintf(stderr
,_("Failed to fetch %s %s\n"),(*I
)->DescURI().c_str(),
1331 (*I
)->ErrorText
.c_str());
1335 /* If we are in no download mode and missing files and there were
1336 'failures' then the user must specify -m. Furthermore, there
1337 is no such thing as a transient error in no-download mode! */
1338 if (Transient
== true &&
1339 _config
->FindB("APT::Get::Download",true) == false)
1345 if (_config
->FindB("APT::Get::Download-Only",false) == true)
1347 if (Failed
== true && _config
->FindB("APT::Get::Fix-Missing",false) == false)
1348 return _error
->Error(_("Some files failed to download"));
1349 c1out
<< _("Download complete and in download only mode") << endl
;
1353 if (Failed
== true && _config
->FindB("APT::Get::Fix-Missing",false) == false)
1355 return _error
->Error(_("Unable to fetch some archives, maybe run apt-get update or try with --fix-missing?"));
1358 if (Transient
== true && Failed
== true)
1359 return _error
->Error(_("--fix-missing and media swapping is not currently supported"));
1361 // Try to deal with missing package files
1362 if (Failed
== true && PM
->FixMissing() == false)
1364 cerr
<< _("Unable to correct missing packages.") << endl
;
1365 return _error
->Error(_("Aborting install."));
1369 int status_fd
= _config
->FindI("APT::Status-Fd",-1);
1370 pkgPackageManager::OrderResult Res
= PM
->DoInstall(status_fd
);
1371 if (Res
== pkgPackageManager::Failed
|| _error
->PendingError() == true)
1373 if (Res
== pkgPackageManager::Completed
)
1376 // Reload the fetcher object and loop again for media swapping
1378 if (PM
->GetArchives(&Fetcher
,List
,&Recs
) == false)
1384 std::set
<std::string
> const disappearedPkgs
= PM
->GetDisappearedPackages();
1385 if (disappearedPkgs
.empty() == true)
1389 for (std::set
<std::string
>::const_iterator d
= disappearedPkgs
.begin();
1390 d
!= disappearedPkgs
.end(); ++d
)
1391 disappear
.append(*d
).append(" ");
1393 ShowList(c1out
, P_("The following package disappeared from your system as\n"
1394 "all files have been overwritten by other packages:",
1395 "The following packages disappeared from your system as\n"
1396 "all files have been overwritten by other packages:", disappearedPkgs
.size()), disappear
, "");
1397 c0out
<< _("Note: This is done automatic and on purpose by dpkg.") << std::endl
;
1402 // TryToInstallBuildDep - Try to install a single package /*{{{*/
1403 // ---------------------------------------------------------------------
1404 /* This used to be inlined in DoInstall, but with the advent of regex package
1405 name matching it was split out.. */
1406 bool TryToInstallBuildDep(pkgCache::PkgIterator Pkg
,pkgCacheFile
&Cache
,
1407 pkgProblemResolver
&Fix
,bool Remove
,bool BrokenFix
,
1408 bool AllowFail
= true)
1410 if (Cache
[Pkg
].CandidateVer
== 0 && Pkg
->ProvidesList
!= 0)
1412 CacheSetHelperAPTGet
helper(c1out
);
1413 helper
.showErrors(AllowFail
== false);
1414 pkgCache::VerIterator Ver
= helper
.canNotFindNewestVer(Cache
, Pkg
);
1415 if (Ver
.end() == false)
1416 Pkg
= Ver
.ParentPkg();
1417 else if (helper
.showVirtualPackageErrors(Cache
) == false)
1421 if (_config
->FindB("Debug::BuildDeps",false) == true)
1424 cout
<< " Trying to remove " << Pkg
<< endl
;
1426 cout
<< " Trying to install " << Pkg
<< endl
;
1431 TryToRemove
RemoveAction(Cache
, &Fix
);
1432 RemoveAction(Pkg
.VersionList());
1433 } else if (Cache
[Pkg
].CandidateVer
!= 0) {
1434 TryToInstall
InstallAction(Cache
, &Fix
, BrokenFix
);
1435 InstallAction(Cache
[Pkg
].CandidateVerIter(Cache
));
1436 InstallAction
.doAutoInstall();
1443 // FindSrc - Find a source record /*{{{*/
1444 // ---------------------------------------------------------------------
1446 pkgSrcRecords::Parser
*FindSrc(const char *Name
,pkgRecords
&Recs
,
1447 pkgSrcRecords
&SrcRecs
,string
&Src
,
1451 string DefRel
= _config
->Find("APT::Default-Release");
1452 string TmpSrc
= Name
;
1454 // extract the version/release from the pkgname
1455 const size_t found
= TmpSrc
.find_last_of("/=");
1456 if (found
!= string::npos
) {
1457 if (TmpSrc
[found
] == '/')
1458 DefRel
= TmpSrc
.substr(found
+1);
1460 VerTag
= TmpSrc
.substr(found
+1);
1461 TmpSrc
= TmpSrc
.substr(0,found
);
1464 /* Lookup the version of the package we would install if we were to
1465 install a version and determine the source package name, then look
1466 in the archive for a source package of the same name. */
1467 bool MatchSrcOnly
= _config
->FindB("APT::Get::Only-Source");
1468 const pkgCache::PkgIterator Pkg
= Cache
.FindPkg(TmpSrc
);
1469 if (MatchSrcOnly
== false && Pkg
.end() == false)
1471 if(VerTag
.empty() == false || DefRel
.empty() == false)
1474 // we have a default release, try to locate the pkg. we do it like
1475 // this because GetCandidateVer() will not "downgrade", that means
1476 // "apt-get source -t stable apt" won't work on a unstable system
1477 for (pkgCache::VerIterator Ver
= Pkg
.VersionList();; ++Ver
)
1479 // try first only exact matches, later fuzzy matches
1480 if (Ver
.end() == true)
1485 Ver
= Pkg
.VersionList();
1486 // exit right away from the Pkg.VersionList() loop if we
1487 // don't have any versions
1488 if (Ver
.end() == true)
1491 // We match against a concrete version (or a part of this version)
1492 if (VerTag
.empty() == false &&
1493 (fuzzy
== true || Cache
.VS().CmpVersion(VerTag
, Ver
.VerStr()) != 0) && // exact match
1494 (fuzzy
== false || strncmp(VerTag
.c_str(), Ver
.VerStr(), VerTag
.size()) != 0)) // fuzzy match
1497 for (pkgCache::VerFileIterator VF
= Ver
.FileList();
1498 VF
.end() == false; ++VF
)
1500 /* If this is the status file, and the current version is not the
1501 version in the status file (ie it is not installed, or somesuch)
1502 then it is not a candidate for installation, ever. This weeds
1503 out bogus entries that may be due to config-file states, or
1505 if ((VF
.File()->Flags
& pkgCache::Flag::NotSource
) ==
1506 pkgCache::Flag::NotSource
&& Pkg
.CurrentVer() != Ver
)
1509 // or we match against a release
1510 if(VerTag
.empty() == false ||
1511 (VF
.File().Archive() != 0 && VF
.File().Archive() == DefRel
) ||
1512 (VF
.File().Codename() != 0 && VF
.File().Codename() == DefRel
))
1514 pkgRecords::Parser
&Parse
= Recs
.Lookup(VF
);
1515 Src
= Parse
.SourcePkg();
1516 // no SourcePkg name, so it is the "binary" name
1517 if (Src
.empty() == true)
1519 // the Version we have is possibly fuzzy or includes binUploads,
1520 // so we use the Version of the SourcePkg (empty if same as package)
1521 VerTag
= Parse
.SourceVer();
1522 if (VerTag
.empty() == true)
1523 VerTag
= Ver
.VerStr();
1527 if (Src
.empty() == false)
1530 if (Src
.empty() == true)
1532 // Sources files have no codename information
1533 if (VerTag
.empty() == true && DefRel
.empty() == false)
1535 _error
->Error(_("Ignore unavailable target release '%s' of package '%s'"), DefRel
.c_str(), TmpSrc
.c_str());
1540 if (Src
.empty() == true)
1542 // if we don't have found a fitting package yet so we will
1543 // choose a good candidate and proceed with that.
1544 // Maybe we will find a source later on with the right VerTag
1545 pkgCache::VerIterator Ver
= Cache
.GetCandidateVer(Pkg
);
1546 if (Ver
.end() == false)
1548 pkgRecords::Parser
&Parse
= Recs
.Lookup(Ver
.FileList());
1549 Src
= Parse
.SourcePkg();
1550 if (VerTag
.empty() == true)
1551 VerTag
= Parse
.SourceVer();
1556 if (Src
.empty() == true)
1560 /* if we have a source pkg name, make sure to only search
1561 for srcpkg names, otherwise apt gets confused if there
1562 is a binary package "pkg1" and a source package "pkg1"
1563 with the same name but that comes from different packages */
1564 MatchSrcOnly
= true;
1567 ioprintf(c1out
, _("Picking '%s' as source package instead of '%s'\n"), Src
.c_str(), TmpSrc
.c_str());
1572 pkgSrcRecords::Parser
*Last
= 0;
1573 unsigned long Offset
= 0;
1576 /* Iterate over all of the hits, which includes the resulting
1577 binary packages in the search */
1578 pkgSrcRecords::Parser
*Parse
;
1582 while ((Parse
= SrcRecs
.Find(Src
.c_str(), MatchSrcOnly
)) != 0)
1584 const string Ver
= Parse
->Version();
1586 // Ignore all versions which doesn't fit
1587 if (VerTag
.empty() == false &&
1588 Cache
.VS().CmpVersion(VerTag
, Ver
) != 0) // exact match
1591 // Newer version or an exact match? Save the hit
1592 if (Last
== 0 || Cache
.VS().CmpVersion(Version
,Ver
) < 0) {
1594 Offset
= Parse
->Offset();
1598 // was the version check above an exact match? If so, we don't need to look further
1599 if (VerTag
.empty() == false && VerTag
.size() == Ver
.size())
1602 if (Last
!= 0 || VerTag
.empty() == true)
1604 //if (VerTag.empty() == false && Last == 0)
1605 _error
->Error(_("Ignore unavailable version '%s' of package '%s'"), VerTag
.c_str(), TmpSrc
.c_str());
1609 if (Last
== 0 || Last
->Jump(Offset
) == false)
1615 // DoUpdate - Update the package lists /*{{{*/
1616 // ---------------------------------------------------------------------
1618 bool DoUpdate(CommandLine
&CmdL
)
1620 if (CmdL
.FileSize() != 1)
1621 return _error
->Error(_("The update command takes no arguments"));
1625 // Get the source list
1626 if (Cache
.BuildSourceList() == false)
1628 pkgSourceList
*List
= Cache
.GetSourceList();
1630 // Create the progress
1631 AcqTextStatus
Stat(ScreenWidth
,_config
->FindI("quiet",0));
1633 // Just print out the uris an exit if the --print-uris flag was used
1634 if (_config
->FindB("APT::Get::Print-URIs") == true)
1636 // force a hashsum for compatibility reasons
1637 _config
->CndSet("Acquire::ForceHash", "md5sum");
1641 if (Fetcher
.Setup(&Stat
) == false)
1644 // Populate it with the source selection and get all Indexes
1646 if (List
->GetIndexes(&Fetcher
,true) == false)
1649 pkgAcquire::UriIterator I
= Fetcher
.UriBegin();
1650 for (; I
!= Fetcher
.UriEnd(); ++I
)
1651 cout
<< '\'' << I
->URI
<< "' " << flNotDir(I
->Owner
->DestFile
) << ' ' <<
1652 I
->Owner
->FileSize
<< ' ' << I
->Owner
->HashSum() << endl
;
1657 if (_config
->FindB("APT::Get::Download",true) == true)
1658 ListUpdate(Stat
, *List
);
1660 // Rebuild the cache.
1661 pkgCacheFile::RemoveCaches();
1662 if (Cache
.BuildCaches() == false)
1668 // DoAutomaticRemove - Remove all automatic unused packages /*{{{*/
1669 // ---------------------------------------------------------------------
1670 /* Remove unused automatic packages */
1671 bool DoAutomaticRemove(CacheFile
&Cache
)
1673 bool Debug
= _config
->FindI("Debug::pkgAutoRemove",false);
1674 bool doAutoRemove
= _config
->FindB("APT::Get::AutomaticRemove", false);
1675 bool hideAutoRemove
= _config
->FindB("APT::Get::HideAutoRemove");
1677 pkgDepCache::ActionGroup
group(*Cache
);
1679 std::cout
<< "DoAutomaticRemove()" << std::endl
;
1681 if (doAutoRemove
== true &&
1682 _config
->FindB("APT::Get::Remove",true) == false)
1684 c1out
<< _("We are not supposed to delete stuff, can't start "
1685 "AutoRemover") << std::endl
;
1689 bool purgePkgs
= _config
->FindB("APT::Get::Purge", false);
1690 bool smallList
= (hideAutoRemove
== false &&
1691 strcasecmp(_config
->Find("APT::Get::HideAutoRemove","").c_str(),"small") == 0);
1693 string autoremovelist
, autoremoveversions
;
1694 unsigned long autoRemoveCount
= 0;
1695 APT::PackageSet tooMuch
;
1696 // look over the cache to see what can be removed
1697 for (pkgCache::PkgIterator Pkg
= Cache
->PkgBegin(); ! Pkg
.end(); ++Pkg
)
1699 if (Cache
[Pkg
].Garbage
)
1701 if(Pkg
.CurrentVer() != 0 || Cache
[Pkg
].Install())
1703 std::cout
<< "We could delete %s" << Pkg
.FullName(true).c_str() << std::endl
;
1707 if(Pkg
.CurrentVer() != 0 &&
1708 Pkg
->CurrentState
!= pkgCache::State::ConfigFiles
)
1709 Cache
->MarkDelete(Pkg
, purgePkgs
);
1711 Cache
->MarkKeep(Pkg
, false, false);
1715 // if the package is a new install and already garbage we don't need to
1716 // install it in the first place, so nuke it instead of show it
1717 if (Cache
[Pkg
].Install() == true && Pkg
.CurrentVer() == 0)
1719 if (Pkg
.CandVersion() != 0)
1720 tooMuch
.insert(Pkg
);
1721 Cache
->MarkDelete(Pkg
, false);
1723 // only show stuff in the list that is not yet marked for removal
1724 else if(hideAutoRemove
== false && Cache
[Pkg
].Delete() == false)
1727 // we don't need to fill the strings if we don't need them
1728 if (smallList
== false)
1730 autoremovelist
+= Pkg
.FullName(true) + " ";
1731 autoremoveversions
+= string(Cache
[Pkg
].CandVersion
) + "\n";
1738 // we could have removed a new dependency of a garbage package,
1739 // so check if a reverse depends is broken and if so install it again.
1740 if (tooMuch
.empty() == false && (Cache
->BrokenCount() != 0 || Cache
->PolicyBrokenCount() != 0))
1745 for (APT::PackageSet::const_iterator Pkg
= tooMuch
.begin();
1746 Pkg
!= tooMuch
.end() && Changed
== false; ++Pkg
)
1748 APT::PackageSet too
;
1750 for (pkgCache::PrvIterator Prv
= Cache
[Pkg
].CandidateVerIter(Cache
).ProvidesList();
1751 Prv
.end() == false; ++Prv
)
1752 too
.insert(Prv
.ParentPkg());
1753 for (APT::PackageSet::const_iterator P
= too
.begin();
1754 P
!= too
.end() && Changed
== false; ++P
) {
1755 for (pkgCache::DepIterator R
= P
.RevDependsList();
1756 R
.end() == false; ++R
)
1758 if (R
.IsNegative() == true ||
1759 Cache
->IsImportantDep(R
) == false)
1761 pkgCache::PkgIterator N
= R
.ParentPkg();
1762 if (N
.end() == true || (N
->CurrentVer
== 0 && (*Cache
)[N
].Install() == false))
1765 std::clog
<< "Save " << Pkg
<< " as another installed garbage package depends on it" << std::endl
;
1766 Cache
->MarkInstall(Pkg
, false);
1767 if (hideAutoRemove
== false)
1770 if (smallList
== false)
1772 autoremovelist
+= Pkg
.FullName(true) + " ";
1773 autoremoveversions
+= string(Cache
[Pkg
].CandVersion
) + "\n";
1782 } while (Changed
== true);
1785 // Now see if we had destroyed anything (if we had done anything)
1786 if (Cache
->BrokenCount() != 0)
1788 c1out
<< _("Hmm, seems like the AutoRemover destroyed something which really\n"
1789 "shouldn't happen. Please file a bug report against apt.") << endl
;
1791 c1out
<< _("The following information may help to resolve the situation:") << endl
;
1793 ShowBroken(c1out
,Cache
,false);
1795 return _error
->Error(_("Internal Error, AutoRemover broke stuff"));
1798 // if we don't remove them, we should show them!
1799 if (doAutoRemove
== false && (autoremovelist
.empty() == false || autoRemoveCount
!= 0))
1801 if (smallList
== false)
1802 ShowList(c1out
, P_("The following package was automatically installed and is no longer required:",
1803 "The following packages were automatically installed and are no longer required:",
1804 autoRemoveCount
), autoremovelist
, autoremoveversions
);
1806 ioprintf(c1out
, P_("%lu package was automatically installed and is no longer required.\n",
1807 "%lu packages were automatically installed and are no longer required.\n", autoRemoveCount
), autoRemoveCount
);
1808 c1out
<< _("Use 'apt-get autoremove' to remove them.") << std::endl
;
1813 // DoUpgrade - Upgrade all packages /*{{{*/
1814 // ---------------------------------------------------------------------
1815 /* Upgrade all packages without installing new packages or erasing old
1817 bool DoUpgrade(CommandLine
&CmdL
)
1820 if (Cache
.OpenForInstall() == false || Cache
.CheckDeps() == false)
1824 if (pkgAllUpgrade(Cache
) == false)
1826 ShowBroken(c1out
,Cache
,false);
1827 return _error
->Error(_("Internal error, AllUpgrade broke stuff"));
1830 return InstallPackages(Cache
,true);
1833 // DoInstall - Install packages from the command line /*{{{*/
1834 // ---------------------------------------------------------------------
1835 /* Install named packages */
1836 bool DoInstall(CommandLine
&CmdL
)
1839 if (Cache
.OpenForInstall() == false ||
1840 Cache
.CheckDeps(CmdL
.FileSize() != 1) == false)
1843 // Enter the special broken fixing mode if the user specified arguments
1844 bool BrokenFix
= false;
1845 if (Cache
->BrokenCount() != 0)
1848 pkgProblemResolver
* Fix
= NULL
;
1849 if (_config
->FindB("APT::Get::CallResolver", true) == true)
1850 Fix
= new pkgProblemResolver(Cache
);
1852 static const unsigned short MOD_REMOVE
= 1;
1853 static const unsigned short MOD_INSTALL
= 2;
1855 unsigned short fallback
= MOD_INSTALL
;
1856 if (strcasecmp(CmdL
.FileList
[0],"remove") == 0)
1857 fallback
= MOD_REMOVE
;
1858 else if (strcasecmp(CmdL
.FileList
[0], "purge") == 0)
1860 _config
->Set("APT::Get::Purge", true);
1861 fallback
= MOD_REMOVE
;
1863 else if (strcasecmp(CmdL
.FileList
[0], "autoremove") == 0)
1865 _config
->Set("APT::Get::AutomaticRemove", "true");
1866 fallback
= MOD_REMOVE
;
1869 std::list
<APT::VersionSet::Modifier
> mods
;
1870 mods
.push_back(APT::VersionSet::Modifier(MOD_INSTALL
, "+",
1871 APT::VersionSet::Modifier::POSTFIX
, APT::VersionSet::CANDIDATE
));
1872 mods
.push_back(APT::VersionSet::Modifier(MOD_REMOVE
, "-",
1873 APT::VersionSet::Modifier::POSTFIX
, APT::VersionSet::NEWEST
));
1874 CacheSetHelperAPTGet
helper(c0out
);
1875 std::map
<unsigned short, APT::VersionSet
> verset
= APT::VersionSet::GroupedFromCommandLine(Cache
,
1876 CmdL
.FileList
+ 1, mods
, fallback
, helper
);
1878 if (_error
->PendingError() == true)
1880 helper
.showVirtualPackageErrors(Cache
);
1886 unsigned short const order
[] = { MOD_REMOVE
, MOD_INSTALL
, 0 };
1888 TryToInstall
InstallAction(Cache
, Fix
, BrokenFix
);
1889 TryToRemove
RemoveAction(Cache
, Fix
);
1891 // new scope for the ActionGroup
1893 pkgDepCache::ActionGroup
group(Cache
);
1895 for (unsigned short i
= 0; order
[i
] != 0; ++i
)
1897 if (order
[i
] == MOD_INSTALL
)
1898 InstallAction
= std::for_each(verset
[MOD_INSTALL
].begin(), verset
[MOD_INSTALL
].end(), InstallAction
);
1899 else if (order
[i
] == MOD_REMOVE
)
1900 RemoveAction
= std::for_each(verset
[MOD_REMOVE
].begin(), verset
[MOD_REMOVE
].end(), RemoveAction
);
1903 if (Fix
!= NULL
&& _config
->FindB("APT::Get::AutoSolving", true) == true)
1905 for (unsigned short i
= 0; order
[i
] != 0; ++i
)
1907 if (order
[i
] != MOD_INSTALL
)
1909 InstallAction
.propergateReleaseCandiateSwitching(helper
.selectedByRelease
, c0out
);
1910 InstallAction
.doAutoInstall();
1914 if (_error
->PendingError() == true)
1921 /* If we are in the Broken fixing mode we do not attempt to fix the
1922 problems. This is if the user invoked install without -f and gave
1924 if (BrokenFix
== true && Cache
->BrokenCount() != 0)
1926 c1out
<< _("You might want to run 'apt-get -f install' to correct these:") << endl
;
1927 ShowBroken(c1out
,Cache
,false);
1930 return _error
->Error(_("Unmet dependencies. Try 'apt-get -f install' with no packages (or specify a solution)."));
1935 // Call the scored problem resolver
1936 Fix
->InstallProtect();
1941 // Now we check the state of the packages,
1942 if (Cache
->BrokenCount() != 0)
1945 _("Some packages could not be installed. This may mean that you have\n"
1946 "requested an impossible situation or if you are using the unstable\n"
1947 "distribution that some required packages have not yet been created\n"
1948 "or been moved out of Incoming.") << endl
;
1954 _("Since you only requested a single operation it is extremely likely that\n"
1955 "the package is simply not installable and a bug report against\n"
1956 "that package should be filed.") << endl;
1960 c1out
<< _("The following information may help to resolve the situation:") << endl
;
1962 ShowBroken(c1out
,Cache
,false);
1963 if (_error
->PendingError() == true)
1966 return _error
->Error(_("Broken packages"));
1969 if (!DoAutomaticRemove(Cache
))
1972 /* Print out a list of packages that are going to be installed extra
1973 to what the user asked */
1974 if (Cache
->InstCount() != verset
[MOD_INSTALL
].size())
1977 string VersionsList
;
1978 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
1980 pkgCache::PkgIterator
I(Cache
,Cache
.List
[J
]);
1981 if ((*Cache
)[I
].Install() == false)
1983 pkgCache::VerIterator Cand
= Cache
[I
].CandidateVerIter(Cache
);
1985 if (verset
[MOD_INSTALL
].find(Cand
) != verset
[MOD_INSTALL
].end())
1988 List
+= I
.FullName(true) + " ";
1989 VersionsList
+= string(Cache
[I
].CandVersion
) + "\n";
1992 ShowList(c1out
,_("The following extra packages will be installed:"),List
,VersionsList
);
1995 /* Print out a list of suggested and recommended packages */
1997 string SuggestsList
, RecommendsList
, List
;
1998 string SuggestsVersions
, RecommendsVersions
;
1999 for (unsigned J
= 0; J
< Cache
->Head().PackageCount
; J
++)
2001 pkgCache::PkgIterator
Pkg(Cache
,Cache
.List
[J
]);
2003 /* Just look at the ones we want to install */
2004 if ((*Cache
)[Pkg
].Install() == false)
2007 // get the recommends/suggests for the candidate ver
2008 pkgCache::VerIterator CV
= (*Cache
)[Pkg
].CandidateVerIter(*Cache
);
2009 for (pkgCache::DepIterator D
= CV
.DependsList(); D
.end() == false; )
2011 pkgCache::DepIterator Start
;
2012 pkgCache::DepIterator End
;
2013 D
.GlobOr(Start
,End
); // advances D
2015 // FIXME: we really should display a or-group as a or-group to the user
2016 // the problem is that ShowList is incapable of doing this
2017 string RecommendsOrList
,RecommendsOrVersions
;
2018 string SuggestsOrList
,SuggestsOrVersions
;
2019 bool foundInstalledInOrGroup
= false;
2022 /* Skip if package is installed already, or is about to be */
2023 string target
= Start
.TargetPkg().FullName(true) + " ";
2024 pkgCache::PkgIterator
const TarPkg
= Start
.TargetPkg();
2025 if (TarPkg
->SelectedState
== pkgCache::State::Install
||
2026 TarPkg
->SelectedState
== pkgCache::State::Hold
||
2027 Cache
[Start
.TargetPkg()].Install())
2029 foundInstalledInOrGroup
=true;
2033 /* Skip if we already saw it */
2034 if (int(SuggestsList
.find(target
)) != -1 || int(RecommendsList
.find(target
)) != -1)
2036 foundInstalledInOrGroup
=true;
2040 // this is a dep on a virtual pkg, check if any package that provides it
2041 // should be installed
2042 if(Start
.TargetPkg().ProvidesList() != 0)
2044 pkgCache::PrvIterator I
= Start
.TargetPkg().ProvidesList();
2045 for (; I
.end() == false; ++I
)
2047 pkgCache::PkgIterator Pkg
= I
.OwnerPkg();
2048 if (Cache
[Pkg
].CandidateVerIter(Cache
) == I
.OwnerVer() &&
2049 Pkg
.CurrentVer() != 0)
2050 foundInstalledInOrGroup
=true;
2054 if (Start
->Type
== pkgCache::Dep::Suggests
)
2056 SuggestsOrList
+= target
;
2057 SuggestsOrVersions
+= string(Cache
[Start
.TargetPkg()].CandVersion
) + "\n";
2060 if (Start
->Type
== pkgCache::Dep::Recommends
)
2062 RecommendsOrList
+= target
;
2063 RecommendsOrVersions
+= string(Cache
[Start
.TargetPkg()].CandVersion
) + "\n";
2071 if(foundInstalledInOrGroup
== false)
2073 RecommendsList
+= RecommendsOrList
;
2074 RecommendsVersions
+= RecommendsOrVersions
;
2075 SuggestsList
+= SuggestsOrList
;
2076 SuggestsVersions
+= SuggestsOrVersions
;
2082 ShowList(c1out
,_("Suggested packages:"),SuggestsList
,SuggestsVersions
);
2083 ShowList(c1out
,_("Recommended packages:"),RecommendsList
,RecommendsVersions
);
2087 // if nothing changed in the cache, but only the automark information
2088 // we write the StateFile here, otherwise it will be written in
2090 if (InstallAction
.AutoMarkChanged
> 0 &&
2091 Cache
->DelCount() == 0 && Cache
->InstCount() == 0 &&
2092 Cache
->BadCount() == 0 &&
2093 _config
->FindB("APT::Get::Simulate",false) == false)
2094 Cache
->writeStateFile(NULL
);
2096 // See if we need to prompt
2097 // FIXME: check if really the packages in the set are going to be installed
2098 if (Cache
->InstCount() == verset
[MOD_INSTALL
].size() && Cache
->DelCount() == 0)
2099 return InstallPackages(Cache
,false,false);
2101 return InstallPackages(Cache
,false);
2104 /* mark packages as automatically/manually installed. {{{*/
2105 bool DoMarkAuto(CommandLine
&CmdL
)
2108 int AutoMarkChanged
= 0;
2109 OpTextProgress progress
;
2111 if (Cache
.Open() == false)
2114 if (strcasecmp(CmdL
.FileList
[0],"markauto") == 0)
2116 else if (strcasecmp(CmdL
.FileList
[0],"unmarkauto") == 0)
2119 for (const char **I
= CmdL
.FileList
+ 1; *I
!= 0; I
++)
2122 // Locate the package
2123 pkgCache::PkgIterator Pkg
= Cache
->FindPkg(S
);
2124 if (Pkg
.end() == true) {
2125 return _error
->Error(_("Couldn't find package %s"),S
);
2130 ioprintf(c1out
,_("%s set to manually installed.\n"), Pkg
.Name());
2132 ioprintf(c1out
,_("%s set to automatically installed.\n"),
2135 Cache
->MarkAuto(Pkg
,Action
);
2140 _error
->Notice(_("This command is deprecated. Please use 'apt-mark auto' and 'apt-mark manual' instead."));
2142 if (AutoMarkChanged
&& ! _config
->FindB("APT::Get::Simulate",false))
2143 return Cache
->writeStateFile(NULL
);
2147 // DoDistUpgrade - Automatic smart upgrader /*{{{*/
2148 // ---------------------------------------------------------------------
2149 /* Intelligent upgrader that will install and remove packages at will */
2150 bool DoDistUpgrade(CommandLine
&CmdL
)
2153 if (Cache
.OpenForInstall() == false || Cache
.CheckDeps() == false)
2156 c0out
<< _("Calculating upgrade... ") << flush
;
2157 if (pkgDistUpgrade(*Cache
) == false)
2159 c0out
<< _("Failed") << endl
;
2160 ShowBroken(c1out
,Cache
,false);
2164 c0out
<< _("Done") << endl
;
2166 return InstallPackages(Cache
,true);
2169 // DoDSelectUpgrade - Do an upgrade by following dselects selections /*{{{*/
2170 // ---------------------------------------------------------------------
2171 /* Follows dselect's selections */
2172 bool DoDSelectUpgrade(CommandLine
&CmdL
)
2175 if (Cache
.OpenForInstall() == false || Cache
.CheckDeps() == false)
2178 pkgDepCache::ActionGroup
group(Cache
);
2180 // Install everything with the install flag set
2181 pkgCache::PkgIterator I
= Cache
->PkgBegin();
2182 for (;I
.end() != true; ++I
)
2184 /* Install the package only if it is a new install, the autoupgrader
2185 will deal with the rest */
2186 if (I
->SelectedState
== pkgCache::State::Install
)
2187 Cache
->MarkInstall(I
,false);
2190 /* Now install their deps too, if we do this above then order of
2191 the status file is significant for | groups */
2192 for (I
= Cache
->PkgBegin();I
.end() != true; ++I
)
2194 /* Install the package only if it is a new install, the autoupgrader
2195 will deal with the rest */
2196 if (I
->SelectedState
== pkgCache::State::Install
)
2197 Cache
->MarkInstall(I
,true);
2200 // Apply erasures now, they override everything else.
2201 for (I
= Cache
->PkgBegin();I
.end() != true; ++I
)
2204 if (I
->SelectedState
== pkgCache::State::DeInstall
||
2205 I
->SelectedState
== pkgCache::State::Purge
)
2206 Cache
->MarkDelete(I
,I
->SelectedState
== pkgCache::State::Purge
);
2209 /* Resolve any problems that dselect created, allupgrade cannot handle
2210 such things. We do so quite agressively too.. */
2211 if (Cache
->BrokenCount() != 0)
2213 pkgProblemResolver
Fix(Cache
);
2215 // Hold back held packages.
2216 if (_config
->FindB("APT::Ignore-Hold",false) == false)
2218 for (pkgCache::PkgIterator I
= Cache
->PkgBegin(); I
.end() == false; ++I
)
2220 if (I
->SelectedState
== pkgCache::State::Hold
)
2228 if (Fix
.Resolve() == false)
2230 ShowBroken(c1out
,Cache
,false);
2231 return _error
->Error(_("Internal error, problem resolver broke stuff"));
2235 // Now upgrade everything
2236 if (pkgAllUpgrade(Cache
) == false)
2238 ShowBroken(c1out
,Cache
,false);
2239 return _error
->Error(_("Internal error, problem resolver broke stuff"));
2242 return InstallPackages(Cache
,false);
2245 // DoClean - Remove download archives /*{{{*/
2246 // ---------------------------------------------------------------------
2248 bool DoClean(CommandLine
&CmdL
)
2250 std::string
const archivedir
= _config
->FindDir("Dir::Cache::archives");
2251 std::string
const pkgcache
= _config
->FindFile("Dir::cache::pkgcache");
2252 std::string
const srcpkgcache
= _config
->FindFile("Dir::cache::srcpkgcache");
2254 if (_config
->FindB("APT::Get::Simulate") == true)
2256 cout
<< "Del " << archivedir
<< "* " << archivedir
<< "partial/*"<< endl
2257 << "Del " << pkgcache
<< " " << srcpkgcache
<< endl
;
2261 // Lock the archive directory
2263 if (_config
->FindB("Debug::NoLocking",false) == false)
2265 Lock
.Fd(GetLock(archivedir
+ "lock"));
2266 if (_error
->PendingError() == true)
2267 return _error
->Error(_("Unable to lock the download directory"));
2271 Fetcher
.Clean(archivedir
);
2272 Fetcher
.Clean(archivedir
+ "partial/");
2274 pkgCacheFile::RemoveCaches();
2279 // DoAutoClean - Smartly remove downloaded archives /*{{{*/
2280 // ---------------------------------------------------------------------
2281 /* This is similar to clean but it only purges things that cannot be
2282 downloaded, that is old versions of cached packages. */
2283 class LogCleaner
: public pkgArchiveCleaner
2286 virtual void Erase(const char *File
,string Pkg
,string Ver
,struct stat
&St
)
2288 c1out
<< "Del " << Pkg
<< " " << Ver
<< " [" << SizeToStr(St
.st_size
) << "B]" << endl
;
2290 if (_config
->FindB("APT::Get::Simulate") == false)
2295 bool DoAutoClean(CommandLine
&CmdL
)
2297 // Lock the archive directory
2299 if (_config
->FindB("Debug::NoLocking",false) == false)
2301 Lock
.Fd(GetLock(_config
->FindDir("Dir::Cache::Archives") + "lock"));
2302 if (_error
->PendingError() == true)
2303 return _error
->Error(_("Unable to lock the download directory"));
2307 if (Cache
.Open() == false)
2312 return Cleaner
.Go(_config
->FindDir("Dir::Cache::archives"),*Cache
) &&
2313 Cleaner
.Go(_config
->FindDir("Dir::Cache::archives") + "partial/",*Cache
);
2316 // DoDownload - download a binary /*{{{*/
2317 // ---------------------------------------------------------------------
2318 bool DoDownload(CommandLine
&CmdL
)
2321 if (Cache
.ReadOnlyOpen() == false)
2324 APT::CacheSetHelper
helper(c0out
);
2325 APT::VersionList verset
= APT::VersionList::FromCommandLine(Cache
,
2326 CmdL
.FileList
+ 1, APT::VersionList::CANDIDATE
, helper
);
2328 if (verset
.empty() == true)
2332 AcqTextStatus
Stat(ScreenWidth
, _config
->FindI("quiet",0));
2333 if (_config
->FindB("APT::Get::Print-URIs") == false)
2334 Fetcher
.Setup(&Stat
);
2336 pkgRecords
Recs(Cache
);
2337 pkgSourceList
*SrcList
= Cache
.GetSourceList();
2338 for (APT::VersionList::const_iterator Ver
= verset
.begin();
2339 Ver
!= verset
.end();
2343 // get the right version
2344 pkgCache::PkgIterator Pkg
= Ver
.ParentPkg();
2345 pkgRecords::Parser
&rec
=Recs
.Lookup(Ver
.FileList());
2346 pkgCache::VerFileIterator Vf
= Ver
.FileList();
2347 if (Vf
.end() == true)
2348 return _error
->Error("Can not find VerFile");
2349 pkgCache::PkgFileIterator F
= Vf
.File();
2350 pkgIndexFile
*index
;
2351 if(SrcList
->FindIndex(F
, index
) == false)
2352 return _error
->Error("FindIndex failed");
2353 string uri
= index
->ArchiveURI(rec
.FileName());
2354 strprintf(descr
, _("Downloading %s %s"), Pkg
.Name(), Ver
.VerStr());
2355 // get the most appropriate hash
2357 if (rec
.SHA512Hash() != "")
2358 hash
= HashString("sha512", rec
.SHA512Hash());
2359 if (rec
.SHA256Hash() != "")
2360 hash
= HashString("sha256", rec
.SHA256Hash());
2361 else if (rec
.SHA1Hash() != "")
2362 hash
= HashString("sha1", rec
.SHA1Hash());
2363 else if (rec
.MD5Hash() != "")
2364 hash
= HashString("md5", rec
.MD5Hash());
2366 new pkgAcqFile(&Fetcher
, uri
, hash
.toStr(), (*Ver
)->Size
, descr
, Pkg
.Name(), ".");
2369 // Just print out the uris and exit if the --print-uris flag was used
2370 if (_config
->FindB("APT::Get::Print-URIs") == true)
2372 pkgAcquire::UriIterator I
= Fetcher
.UriBegin();
2373 for (; I
!= Fetcher
.UriEnd(); ++I
)
2374 cout
<< '\'' << I
->URI
<< "' " << flNotDir(I
->Owner
->DestFile
) << ' ' <<
2375 I
->Owner
->FileSize
<< ' ' << I
->Owner
->HashSum() << endl
;
2379 return (Fetcher
.Run() == pkgAcquire::Continue
);
2382 // DoCheck - Perform the check operation /*{{{*/
2383 // ---------------------------------------------------------------------
2384 /* Opening automatically checks the system, this command is mostly used
2386 bool DoCheck(CommandLine
&CmdL
)
2395 // DoSource - Fetch a source archive /*{{{*/
2396 // ---------------------------------------------------------------------
2397 /* Fetch souce packages */
2405 bool DoSource(CommandLine
&CmdL
)
2408 if (Cache
.Open(false) == false)
2411 if (CmdL
.FileSize() <= 1)
2412 return _error
->Error(_("Must specify at least one package to fetch source for"));
2414 // Read the source list
2415 if (Cache
.BuildSourceList() == false)
2417 pkgSourceList
*List
= Cache
.GetSourceList();
2419 // Create the text record parsers
2420 pkgRecords
Recs(Cache
);
2421 pkgSrcRecords
SrcRecs(*List
);
2422 if (_error
->PendingError() == true)
2425 // Create the download object
2426 AcqTextStatus
Stat(ScreenWidth
,_config
->FindI("quiet",0));
2428 Fetcher
.SetLog(&Stat
);
2430 DscFile
*Dsc
= new DscFile
[CmdL
.FileSize()];
2432 // insert all downloaded uris into this set to avoid downloading them
2436 // Diff only mode only fetches .diff files
2437 bool const diffOnly
= _config
->FindB("APT::Get::Diff-Only", false);
2438 // Tar only mode only fetches .tar files
2439 bool const tarOnly
= _config
->FindB("APT::Get::Tar-Only", false);
2440 // Dsc only mode only fetches .dsc files
2441 bool const dscOnly
= _config
->FindB("APT::Get::Dsc-Only", false);
2443 // Load the requestd sources into the fetcher
2445 for (const char **I
= CmdL
.FileList
+ 1; *I
!= 0; I
++, J
++)
2448 pkgSrcRecords::Parser
*Last
= FindSrc(*I
,Recs
,SrcRecs
,Src
,*Cache
);
2452 return _error
->Error(_("Unable to find a source package for %s"),Src
.c_str());
2455 string srec
= Last
->AsStr();
2456 string::size_type pos
= srec
.find("\nVcs-");
2457 while (pos
!= string::npos
)
2459 pos
+= strlen("\nVcs-");
2460 string vcs
= srec
.substr(pos
,srec
.find(":",pos
)-pos
);
2461 if(vcs
== "Browser")
2463 pos
= srec
.find("\nVcs-", pos
);
2466 pos
+= vcs
.length()+2;
2467 string::size_type epos
= srec
.find("\n", pos
);
2468 string uri
= srec
.substr(pos
,epos
-pos
).c_str();
2469 ioprintf(c1out
, _("NOTICE: '%s' packaging is maintained in "
2470 "the '%s' version control system at:\n"
2472 Src
.c_str(), vcs
.c_str(), uri
.c_str());
2474 ioprintf(c1out
,_("Please use:\n"
2476 "to retrieve the latest (possibly unreleased) "
2477 "updates to the package.\n"),
2483 vector
<pkgSrcRecords::File
> Lst
;
2484 if (Last
->Files(Lst
) == false) {
2489 // Load them into the fetcher
2490 for (vector
<pkgSrcRecords::File
>::const_iterator I
= Lst
.begin();
2491 I
!= Lst
.end(); ++I
)
2493 // Try to guess what sort of file it is we are getting.
2494 if (I
->Type
== "dsc")
2496 Dsc
[J
].Package
= Last
->Package();
2497 Dsc
[J
].Version
= Last
->Version();
2498 Dsc
[J
].Dsc
= flNotDir(I
->Path
);
2501 // Handle the only options so that multiple can be used at once
2502 if (diffOnly
== true || tarOnly
== true || dscOnly
== true)
2504 if ((diffOnly
== true && I
->Type
== "diff") ||
2505 (tarOnly
== true && I
->Type
== "tar") ||
2506 (dscOnly
== true && I
->Type
== "dsc"))
2507 ; // Fine, we want this file downloaded
2512 // don't download the same uri twice (should this be moved to
2513 // the fetcher interface itself?)
2514 if(queued
.find(Last
->Index().ArchiveURI(I
->Path
)) != queued
.end())
2516 queued
.insert(Last
->Index().ArchiveURI(I
->Path
));
2518 // check if we have a file with that md5 sum already localy
2519 if(!I
->MD5Hash
.empty() && FileExists(flNotDir(I
->Path
)))
2521 FileFd
Fd(flNotDir(I
->Path
), FileFd::ReadOnly
);
2523 sum
.AddFD(Fd
.Fd(), Fd
.Size());
2525 if((string
)sum
.Result() == I
->MD5Hash
)
2527 ioprintf(c1out
,_("Skipping already downloaded file '%s'\n"),
2528 flNotDir(I
->Path
).c_str());
2533 new pkgAcqFile(&Fetcher
,Last
->Index().ArchiveURI(I
->Path
),
2535 Last
->Index().SourceInfo(*Last
,*I
),Src
);
2539 // Display statistics
2540 unsigned long long FetchBytes
= Fetcher
.FetchNeeded();
2541 unsigned long long FetchPBytes
= Fetcher
.PartialPresent();
2542 unsigned long long DebBytes
= Fetcher
.TotalNeeded();
2544 // Check for enough free space
2546 string OutputDir
= ".";
2547 if (statvfs(OutputDir
.c_str(),&Buf
) != 0) {
2549 if (errno
== EOVERFLOW
)
2550 return _error
->WarningE("statvfs",_("Couldn't determine free space in %s"),
2553 return _error
->Errno("statvfs",_("Couldn't determine free space in %s"),
2555 } else if (unsigned(Buf
.f_bfree
) < (FetchBytes
- FetchPBytes
)/Buf
.f_bsize
)
2558 if (statfs(OutputDir
.c_str(),&Stat
) != 0
2559 #if HAVE_STRUCT_STATFS_F_TYPE
2560 || unsigned(Stat
.f_type
) != RAMFS_MAGIC
2564 return _error
->Error(_("You don't have enough free space in %s"),
2570 if (DebBytes
!= FetchBytes
)
2571 //TRANSLATOR: The required space between number and unit is already included
2572 // in the replacement strings, so %sB will be correctly translate in e.g. 1,5 MB
2573 ioprintf(c1out
,_("Need to get %sB/%sB of source archives.\n"),
2574 SizeToStr(FetchBytes
).c_str(),SizeToStr(DebBytes
).c_str());
2576 //TRANSLATOR: The required space between number and unit is already included
2577 // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
2578 ioprintf(c1out
,_("Need to get %sB of source archives.\n"),
2579 SizeToStr(DebBytes
).c_str());
2581 if (_config
->FindB("APT::Get::Simulate",false) == true)
2583 for (unsigned I
= 0; I
!= J
; I
++)
2584 ioprintf(cout
,_("Fetch source %s\n"),Dsc
[I
].Package
.c_str());
2589 // Just print out the uris an exit if the --print-uris flag was used
2590 if (_config
->FindB("APT::Get::Print-URIs") == true)
2592 pkgAcquire::UriIterator I
= Fetcher
.UriBegin();
2593 for (; I
!= Fetcher
.UriEnd(); ++I
)
2594 cout
<< '\'' << I
->URI
<< "' " << flNotDir(I
->Owner
->DestFile
) << ' ' <<
2595 I
->Owner
->FileSize
<< ' ' << I
->Owner
->HashSum() << endl
;
2601 if (Fetcher
.Run() == pkgAcquire::Failed
)
2607 // Print error messages
2608 bool Failed
= false;
2609 for (pkgAcquire::ItemIterator I
= Fetcher
.ItemsBegin(); I
!= Fetcher
.ItemsEnd(); ++I
)
2611 if ((*I
)->Status
== pkgAcquire::Item::StatDone
&&
2612 (*I
)->Complete
== true)
2615 fprintf(stderr
,_("Failed to fetch %s %s\n"),(*I
)->DescURI().c_str(),
2616 (*I
)->ErrorText
.c_str());
2622 return _error
->Error(_("Failed to fetch some archives."));
2625 if (_config
->FindB("APT::Get::Download-only",false) == true)
2627 c1out
<< _("Download complete and in download only mode") << endl
;
2632 // Unpack the sources
2633 pid_t Process
= ExecFork();
2637 bool const fixBroken
= _config
->FindB("APT::Get::Fix-Broken", false);
2638 for (unsigned I
= 0; I
!= J
; ++I
)
2640 string Dir
= Dsc
[I
].Package
+ '-' + Cache
->VS().UpstreamVersion(Dsc
[I
].Version
.c_str());
2642 // Diff only mode only fetches .diff files
2643 if (_config
->FindB("APT::Get::Diff-Only",false) == true ||
2644 _config
->FindB("APT::Get::Tar-Only",false) == true ||
2645 Dsc
[I
].Dsc
.empty() == true)
2648 // See if the package is already unpacked
2650 if (fixBroken
== false && stat(Dir
.c_str(),&Stat
) == 0 &&
2651 S_ISDIR(Stat
.st_mode
) != 0)
2653 ioprintf(c0out
,_("Skipping unpack of already unpacked source in %s\n"),
2660 snprintf(S
,sizeof(S
),"%s -x %s",
2661 _config
->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(),
2662 Dsc
[I
].Dsc
.c_str());
2665 fprintf(stderr
,_("Unpack command '%s' failed.\n"),S
);
2666 fprintf(stderr
,_("Check if the 'dpkg-dev' package is installed.\n"));
2671 // Try to compile it with dpkg-buildpackage
2672 if (_config
->FindB("APT::Get::Compile",false) == true)
2674 string buildopts
= _config
->Find("APT::Get::Host-Architecture");
2675 if (buildopts
.empty() == false)
2676 buildopts
= "-a " + buildopts
+ " ";
2677 buildopts
.append(_config
->Find("DPkg::Build-Options","-b -uc"));
2679 // Call dpkg-buildpackage
2681 snprintf(S
,sizeof(S
),"cd %s && %s %s",
2683 _config
->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(),
2688 fprintf(stderr
,_("Build command '%s' failed.\n"),S
);
2698 // Wait for the subprocess
2700 while (waitpid(Process
,&Status
,0) != Process
)
2704 return _error
->Errno("waitpid","Couldn't wait for subprocess");
2707 if (WIFEXITED(Status
) == 0 || WEXITSTATUS(Status
) != 0)
2708 return _error
->Error(_("Child process failed"));
2713 // DoBuildDep - Install/removes packages to satisfy build dependencies /*{{{*/
2714 // ---------------------------------------------------------------------
2715 /* This function will look at the build depends list of the given source
2716 package and install the necessary packages to make it true, or fail. */
2717 bool DoBuildDep(CommandLine
&CmdL
)
2721 _config
->Set("APT::Install-Recommends", false);
2723 if (Cache
.Open(true) == false)
2726 if (CmdL
.FileSize() <= 1)
2727 return _error
->Error(_("Must specify at least one package to check builddeps for"));
2729 // Read the source list
2730 if (Cache
.BuildSourceList() == false)
2732 pkgSourceList
*List
= Cache
.GetSourceList();
2734 // Create the text record parsers
2735 pkgRecords
Recs(Cache
);
2736 pkgSrcRecords
SrcRecs(*List
);
2737 if (_error
->PendingError() == true)
2740 // Create the download object
2741 AcqTextStatus
Stat(ScreenWidth
,_config
->FindI("quiet",0));
2743 if (Fetcher
.Setup(&Stat
) == false)
2746 bool StripMultiArch
;
2747 string hostArch
= _config
->Find("APT::Get::Host-Architecture");
2748 if (hostArch
.empty() == false)
2750 std::vector
<std::string
> archs
= APT::Configuration::getArchitectures();
2751 if (std::find(archs
.begin(), archs
.end(), hostArch
) == archs
.end())
2752 return _error
->Error(_("No architecture information available for %s. See apt.conf(5) APT::Architectures for setup"), hostArch
.c_str());
2753 StripMultiArch
= false;
2756 StripMultiArch
= true;
2759 for (const char **I
= CmdL
.FileList
+ 1; *I
!= 0; I
++, J
++)
2762 pkgSrcRecords::Parser
*Last
= FindSrc(*I
,Recs
,SrcRecs
,Src
,*Cache
);
2764 return _error
->Error(_("Unable to find a source package for %s"),Src
.c_str());
2766 // Process the build-dependencies
2767 vector
<pkgSrcRecords::Parser::BuildDepRec
> BuildDeps
;
2768 if (Last
->BuildDepends(BuildDeps
, _config
->FindB("APT::Get::Arch-Only", false), StripMultiArch
) == false)
2769 return _error
->Error(_("Unable to get build-dependency information for %s"),Src
.c_str());
2771 // Also ensure that build-essential packages are present
2772 Configuration::Item
const *Opts
= _config
->Tree("APT::Build-Essential");
2775 for (; Opts
; Opts
= Opts
->Next
)
2777 if (Opts
->Value
.empty() == true)
2780 pkgSrcRecords::Parser::BuildDepRec rec
;
2781 rec
.Package
= Opts
->Value
;
2782 rec
.Type
= pkgSrcRecords::Parser::BuildDependIndep
;
2784 BuildDeps
.push_back(rec
);
2787 if (BuildDeps
.empty() == true)
2789 ioprintf(c1out
,_("%s has no build depends.\n"),Src
.c_str());
2793 // Install the requested packages
2794 vector
<pkgSrcRecords::Parser::BuildDepRec
>::iterator D
;
2795 pkgProblemResolver
Fix(Cache
);
2796 bool skipAlternatives
= false; // skip remaining alternatives in an or group
2797 for (D
= BuildDeps
.begin(); D
!= BuildDeps
.end(); ++D
)
2799 bool hasAlternatives
= (((*D
).Op
& pkgCache::Dep::Or
) == pkgCache::Dep::Or
);
2801 if (skipAlternatives
== true)
2804 * if there are alternatives, we've already picked one, so skip
2807 * TODO: this means that if there's a build-dep on A|B and B is
2808 * installed, we'll still try to install A; more importantly,
2809 * if A is currently broken, we cannot go back and try B. To fix
2810 * this would require we do a Resolve cycle for each package we
2811 * add to the install list. Ugh
2813 if (!hasAlternatives
)
2814 skipAlternatives
= false; // end of or group
2818 if ((*D
).Type
== pkgSrcRecords::Parser::BuildConflict
||
2819 (*D
).Type
== pkgSrcRecords::Parser::BuildConflictIndep
)
2821 pkgCache::GrpIterator Grp
= Cache
->FindGrp((*D
).Package
);
2822 // Build-conflicts on unknown packages are silently ignored
2823 if (Grp
.end() == true)
2826 for (pkgCache::PkgIterator Pkg
= Grp
.PackageList(); Pkg
.end() == false; Pkg
= Grp
.NextPkg(Pkg
))
2828 pkgCache::VerIterator IV
= (*Cache
)[Pkg
].InstVerIter(*Cache
);
2830 * Remove if we have an installed version that satisfies the
2833 if (IV
.end() == false &&
2834 Cache
->VS().CheckDep(IV
.VerStr(),(*D
).Op
,(*D
).Version
.c_str()) == true)
2835 TryToInstallBuildDep(Pkg
,Cache
,Fix
,true,false);
2838 else // BuildDep || BuildDepIndep
2840 if (_config
->FindB("Debug::BuildDeps",false) == true)
2841 cout
<< "Looking for " << (*D
).Package
<< "...\n";
2843 pkgCache::PkgIterator Pkg
;
2846 if (StripMultiArch
== false)
2848 size_t const colon
= D
->Package
.find(":");
2849 if (colon
!= string::npos
&&
2850 (strcmp(D
->Package
.c_str() + colon
, ":any") == 0 || strcmp(D
->Package
.c_str() + colon
, ":native") == 0))
2851 Pkg
= Cache
->FindPkg(D
->Package
.substr(0,colon
));
2853 Pkg
= Cache
->FindPkg(D
->Package
);
2855 // We need to decide if host or build arch, so find a version we can look at
2856 pkgCache::VerIterator Ver
;
2858 // a bad version either is invalid or doesn't satify dependency
2859 #define BADVER(Ver) Ver.end() == true || \
2860 (Ver.end() == false && D->Version.empty() == false && \
2861 Cache->VS().CheckDep(Ver.VerStr(),D->Op,D->Version.c_str()) == false)
2863 if (Pkg
.end() == false)
2865 Ver
= (*Cache
)[Pkg
].InstVerIter(*Cache
);
2867 Ver
= (*Cache
)[Pkg
].CandidateVerIter(*Cache
);
2871 pkgCache::PkgIterator HostPkg
= Cache
->FindPkg(D
->Package
, hostArch
);
2872 if (HostPkg
.end() == false)
2874 Ver
= (*Cache
)[HostPkg
].InstVerIter(*Cache
);
2876 Ver
= (*Cache
)[HostPkg
].CandidateVerIter(*Cache
);
2879 if ((BADVER(Ver
)) == false)
2882 if (Ver
->MultiArch
== pkgCache::Version::None
|| Ver
->MultiArch
== pkgCache::Version::All
)
2884 if (colon
== string::npos
)
2886 Pkg
= Ver
.ParentPkg().Group().FindPkg(hostArch
);
2889 else if (Ver
->MultiArch
== pkgCache::Version::Same
)
2891 if (colon
== string::npos
)
2892 Pkg
= Ver
.ParentPkg().Group().FindPkg(hostArch
);
2893 else if (strcmp(D
->Package
.c_str() + colon
, ":any") == 0)
2894 forbidden
= "Multi-Arch: same";
2895 // :native gets the buildArch
2897 else if ((Ver
->MultiArch
& pkgCache::Version::Foreign
) == pkgCache::Version::Foreign
)
2899 if (colon
!= string::npos
)
2900 forbidden
= "Multi-Arch: foreign";
2902 else if ((Ver
->MultiArch
& pkgCache::Version::Allowed
) == pkgCache::Version::Allowed
)
2904 if (colon
== string::npos
)
2905 Pkg
= Ver
.ParentPkg().Group().FindPkg(hostArch
);
2906 else if (strcmp(D
->Package
.c_str() + colon
, ":any") == 0)
2908 // prefer any installed over preferred non-installed architectures
2909 pkgCache::GrpIterator Grp
= Ver
.ParentPkg().Group();
2910 // we don't check for version here as we are better of with upgrading than remove and install
2911 for (Pkg
= Grp
.PackageList(); Pkg
.end() == false; Pkg
= Grp
.NextPkg(Pkg
))
2912 if (Pkg
.CurrentVer().end() == false)
2914 if (Pkg
.end() == true)
2915 Pkg
= Grp
.FindPreferredPkg(true);
2917 // native gets buildArch
2919 if (forbidden
.empty() == false)
2921 if (_config
->FindB("Debug::BuildDeps",false) == true)
2922 cout
<< " :any is not allowed from M-A: same package " << (*D
).Package
<< endl
;
2923 if (hasAlternatives
)
2925 return _error
->Error(_("%s dependency for %s can't be satisfied "
2926 "because %s is not allowed on '%s' packages"),
2927 Last
->BuildDepType(D
->Type
), Src
.c_str(),
2928 D
->Package
.c_str(), "Multi-Arch: same");
2931 else if (_config
->FindB("Debug::BuildDeps",false) == true)
2932 cout
<< " No multiarch info as we have no satisfying installed nor candidate for " << D
->Package
<< " on build or host arch" << endl
;
2936 Pkg
= Cache
->FindPkg(D
->Package
);
2938 if (Pkg
.end() == true)
2940 if (_config
->FindB("Debug::BuildDeps",false) == true)
2941 cout
<< " (not found)" << (*D
).Package
<< endl
;
2943 if (hasAlternatives
)
2946 return _error
->Error(_("%s dependency for %s cannot be satisfied "
2947 "because the package %s cannot be found"),
2948 Last
->BuildDepType((*D
).Type
),Src
.c_str(),
2949 (*D
).Package
.c_str());
2952 pkgCache::VerIterator IV
= (*Cache
)[Pkg
].InstVerIter(*Cache
);
2953 if (IV
.end() == false)
2955 if (_config
->FindB("Debug::BuildDeps",false) == true)
2956 cout
<< " Is installed\n";
2958 if (D
->Version
.empty() == true ||
2959 Cache
->VS().CheckDep(IV
.VerStr(),(*D
).Op
,(*D
).Version
.c_str()) == true)
2961 skipAlternatives
= hasAlternatives
;
2965 if (_config
->FindB("Debug::BuildDeps",false) == true)
2966 cout
<< " ...but the installed version doesn't meet the version requirement\n";
2968 if (((*D
).Op
& pkgCache::Dep::LessEq
) == pkgCache::Dep::LessEq
)
2969 return _error
->Error(_("Failed to satisfy %s dependency for %s: Installed package %s is too new"),
2970 Last
->BuildDepType((*D
).Type
), Src
.c_str(), Pkg
.FullName(true).c_str());
2973 // Only consider virtual packages if there is no versioned dependency
2974 if ((*D
).Version
.empty() == true)
2977 * If this is a virtual package, we need to check the list of
2978 * packages that provide it and see if any of those are
2981 pkgCache::PrvIterator Prv
= Pkg
.ProvidesList();
2982 for (; Prv
.end() != true; ++Prv
)
2984 if (_config
->FindB("Debug::BuildDeps",false) == true)
2985 cout
<< " Checking provider " << Prv
.OwnerPkg().FullName() << endl
;
2987 if ((*Cache
)[Prv
.OwnerPkg()].InstVerIter(*Cache
).end() == false)
2991 if (Prv
.end() == false)
2993 if (_config
->FindB("Debug::BuildDeps",false) == true)
2994 cout
<< " Is provided by installed package " << Prv
.OwnerPkg().FullName() << endl
;
2995 skipAlternatives
= hasAlternatives
;
2999 else // versioned dependency
3001 pkgCache::VerIterator CV
= (*Cache
)[Pkg
].CandidateVerIter(*Cache
);
3002 if (CV
.end() == true ||
3003 Cache
->VS().CheckDep(CV
.VerStr(),(*D
).Op
,(*D
).Version
.c_str()) == false)
3005 if (hasAlternatives
)
3007 else if (CV
.end() == false)
3008 return _error
->Error(_("%s dependency for %s cannot be satisfied "
3009 "because candidate version of package %s "
3010 "can't satisfy version requirements"),
3011 Last
->BuildDepType(D
->Type
), Src
.c_str(),
3012 D
->Package
.c_str());
3014 return _error
->Error(_("%s dependency for %s cannot be satisfied "
3015 "because package %s has no candidate version"),
3016 Last
->BuildDepType(D
->Type
), Src
.c_str(),
3017 D
->Package
.c_str());
3021 if (TryToInstallBuildDep(Pkg
,Cache
,Fix
,false,false) == true)
3023 // We successfully installed something; skip remaining alternatives
3024 skipAlternatives
= hasAlternatives
;
3025 if(_config
->FindB("APT::Get::Build-Dep-Automatic", false) == true)
3026 Cache
->MarkAuto(Pkg
, true);
3029 else if (hasAlternatives
)
3031 if (_config
->FindB("Debug::BuildDeps",false) == true)
3032 cout
<< " Unsatisfiable, trying alternatives\n";
3037 return _error
->Error(_("Failed to satisfy %s dependency for %s: %s"),
3038 Last
->BuildDepType((*D
).Type
),
3040 (*D
).Package
.c_str());
3045 Fix
.InstallProtect();
3046 if (Fix
.Resolve(true) == false)
3049 // Now we check the state of the packages,
3050 if (Cache
->BrokenCount() != 0)
3052 ShowBroken(cout
, Cache
, false);
3053 return _error
->Error(_("Build-dependencies for %s could not be satisfied."),*I
);
3057 if (InstallPackages(Cache
, false, true) == false)
3058 return _error
->Error(_("Failed to process build dependencies"));
3062 // GetChangelogPath - return a path pointing to a changelog file or dir /*{{{*/
3063 // ---------------------------------------------------------------------
3064 /* This returns a "path" string for the changelog url construction.
3065 * Please note that its not complete, it either needs a "/changelog"
3066 * appended (for the packages.debian.org/changelogs site) or a
3067 * ".changelog" (for third party sites that store the changelog in the
3068 * pool/ next to the deb itself)
3069 * Example return: "pool/main/a/apt/apt_0.8.8ubuntu3"
3071 string
GetChangelogPath(CacheFile
&Cache
,
3072 pkgCache::PkgIterator Pkg
,
3073 pkgCache::VerIterator Ver
)
3077 pkgRecords
Recs(Cache
);
3078 pkgRecords::Parser
&rec
=Recs
.Lookup(Ver
.FileList());
3079 string srcpkg
= rec
.SourcePkg().empty() ? Pkg
.Name() : rec
.SourcePkg();
3080 string ver
= Ver
.VerStr();
3081 // if there is a source version it always wins
3082 if (rec
.SourceVer() != "")
3083 ver
= rec
.SourceVer();
3084 path
= flNotFile(rec
.FileName());
3085 path
+= srcpkg
+ "_" + StripEpoch(ver
);
3089 // GuessThirdPartyChangelogUri - return url /*{{{*/
3090 // ---------------------------------------------------------------------
3091 /* Contruct a changelog file path for third party sites that do not use
3092 * packages.debian.org/changelogs
3093 * This simply uses the ArchiveURI() of the source pkg and looks for
3094 * a .changelog file there, Example for "mediabuntu":
3095 * apt-get changelog mplayer-doc:
3096 * http://packages.medibuntu.org/pool/non-free/m/mplayer/mplayer_1.0~rc4~try1.dsfg1-1ubuntu1+medibuntu1.changelog
3098 bool GuessThirdPartyChangelogUri(CacheFile
&Cache
,
3099 pkgCache::PkgIterator Pkg
,
3100 pkgCache::VerIterator Ver
,
3103 // get the binary deb server path
3104 pkgCache::VerFileIterator Vf
= Ver
.FileList();
3105 if (Vf
.end() == true)
3107 pkgCache::PkgFileIterator F
= Vf
.File();
3108 pkgIndexFile
*index
;
3109 pkgSourceList
*SrcList
= Cache
.GetSourceList();
3110 if(SrcList
->FindIndex(F
, index
) == false)
3113 // get archive uri for the binary deb
3114 string path_without_dot_changelog
= GetChangelogPath(Cache
, Pkg
, Ver
);
3115 out_uri
= index
->ArchiveURI(path_without_dot_changelog
+ ".changelog");
3117 // now strip away the filename and add srcpkg_srcver.changelog
3121 // DownloadChangelog - Download the changelog /*{{{*/
3122 // ---------------------------------------------------------------------
3123 bool DownloadChangelog(CacheFile
&CacheFile
, pkgAcquire
&Fetcher
,
3124 pkgCache::VerIterator Ver
, string targetfile
)
3125 /* Download a changelog file for the given package version to
3126 * targetfile. This will first try the server from Apt::Changelogs::Server
3127 * (http://packages.debian.org/changelogs by default) and if that gives
3128 * a 404 tries to get it from the archive directly (see
3129 * GuessThirdPartyChangelogUri for details how)
3135 string changelog_uri
;
3137 // data structures we need
3138 pkgCache::PkgIterator Pkg
= Ver
.ParentPkg();
3140 // make the server root configurable
3141 server
= _config
->Find("Apt::Changelogs::Server",
3142 "http://packages.debian.org/changelogs");
3143 path
= GetChangelogPath(CacheFile
, Pkg
, Ver
);
3144 strprintf(changelog_uri
, "%s/%s/changelog", server
.c_str(), path
.c_str());
3145 if (_config
->FindB("APT::Get::Print-URIs", false) == true)
3147 std::cout
<< '\'' << changelog_uri
<< '\'' << std::endl
;
3151 strprintf(descr
, _("Changelog for %s (%s)"), Pkg
.Name(), changelog_uri
.c_str());
3153 new pkgAcqFile(&Fetcher
, changelog_uri
, "", 0, descr
, Pkg
.Name(), "ignored", targetfile
);
3155 // try downloading it, if that fails, try third-party-changelogs location
3156 // FIXME: Fetcher.Run() is "Continue" even if I get a 404?!?
3158 if (!FileExists(targetfile
))
3160 string third_party_uri
;
3161 if (GuessThirdPartyChangelogUri(CacheFile
, Pkg
, Ver
, third_party_uri
))
3163 strprintf(descr
, _("Changelog for %s (%s)"), Pkg
.Name(), third_party_uri
.c_str());
3164 new pkgAcqFile(&Fetcher
, third_party_uri
, "", 0, descr
, Pkg
.Name(), "ignored", targetfile
);
3169 if (FileExists(targetfile
))
3173 return _error
->Error("changelog download failed");
3176 // DisplayFileInPager - Display File with pager /*{{{*/
3177 void DisplayFileInPager(string filename
)
3179 pid_t Process
= ExecFork();
3182 const char *Args
[3];
3183 Args
[0] = "/usr/bin/sensible-pager";
3184 Args
[1] = filename
.c_str();
3186 execvp(Args
[0],(char **)Args
);
3190 // Wait for the subprocess
3191 ExecWait(Process
, "sensible-pager", false);
3194 // DoChangelog - Get changelog from the command line /*{{{*/
3195 // ---------------------------------------------------------------------
3196 bool DoChangelog(CommandLine
&CmdL
)
3199 if (Cache
.ReadOnlyOpen() == false)
3202 APT::CacheSetHelper
helper(c0out
);
3203 APT::VersionList verset
= APT::VersionList::FromCommandLine(Cache
,
3204 CmdL
.FileList
+ 1, APT::VersionList::CANDIDATE
, helper
);
3205 if (verset
.empty() == true)
3209 if (_config
->FindB("APT::Get::Print-URIs", false) == true)
3210 for (APT::VersionList::const_iterator Ver
= verset
.begin();
3211 Ver
!= verset
.end(); ++Ver
)
3212 return DownloadChangelog(Cache
, Fetcher
, Ver
, "");
3214 AcqTextStatus
Stat(ScreenWidth
, _config
->FindI("quiet",0));
3215 Fetcher
.Setup(&Stat
);
3217 bool const downOnly
= _config
->FindB("APT::Get::Download-Only", false);
3220 char* tmpdir
= NULL
;
3221 if (downOnly
== false)
3223 const char* const tmpDir
= getenv("TMPDIR");
3224 if (tmpDir
!= NULL
&& *tmpDir
!= '\0')
3225 snprintf(tmpname
, sizeof(tmpname
), "%s/apt-changelog-XXXXXX", tmpDir
);
3227 strncpy(tmpname
, "/tmp/apt-changelog-XXXXXX", sizeof(tmpname
));
3228 tmpdir
= mkdtemp(tmpname
);
3230 return _error
->Errno("mkdtemp", "mkdtemp failed");
3233 for (APT::VersionList::const_iterator Ver
= verset
.begin();
3234 Ver
!= verset
.end();
3237 string changelogfile
;
3238 if (downOnly
== false)
3239 changelogfile
.append(tmpname
).append("changelog");
3241 changelogfile
.append(Ver
.ParentPkg().Name()).append(".changelog");
3242 if (DownloadChangelog(Cache
, Fetcher
, Ver
, changelogfile
) && downOnly
== false)
3244 DisplayFileInPager(changelogfile
);
3245 // cleanup temp file
3246 unlink(changelogfile
.c_str());
3255 // DoMoo - Never Ask, Never Tell /*{{{*/
3256 // ---------------------------------------------------------------------
3258 bool DoMoo(CommandLine
&CmdL
)
3267 "....\"Have you mooed today?\"...\n";
3272 // ShowHelp - Show a help screen /*{{{*/
3273 // ---------------------------------------------------------------------
3275 bool ShowHelp(CommandLine
&CmdL
)
3277 ioprintf(cout
,_("%s %s for %s compiled on %s %s\n"),PACKAGE
,VERSION
,
3278 COMMON_ARCH
,__DATE__
,__TIME__
);
3280 if (_config
->FindB("version") == true)
3282 cout
<< _("Supported modules:") << endl
;
3284 for (unsigned I
= 0; I
!= pkgVersioningSystem::GlobalListLen
; I
++)
3286 pkgVersioningSystem
*VS
= pkgVersioningSystem::GlobalList
[I
];
3287 if (_system
!= 0 && _system
->VS
== VS
)
3291 cout
<< "Ver: " << VS
->Label
<< endl
;
3293 /* Print out all the packaging systems that will work with
3295 for (unsigned J
= 0; J
!= pkgSystem::GlobalListLen
; J
++)
3297 pkgSystem
*Sys
= pkgSystem::GlobalList
[J
];
3302 if (Sys
->VS
->TestCompatibility(*VS
) == true)
3303 cout
<< "Pkg: " << Sys
->Label
<< " (Priority " << Sys
->Score(*_config
) << ")" << endl
;
3307 for (unsigned I
= 0; I
!= pkgSourceList::Type::GlobalListLen
; I
++)
3309 pkgSourceList::Type
*Type
= pkgSourceList::Type::GlobalList
[I
];
3310 cout
<< " S.L: '" << Type
->Name
<< "' " << Type
->Label
<< endl
;
3313 for (unsigned I
= 0; I
!= pkgIndexFile::Type::GlobalListLen
; I
++)
3315 pkgIndexFile::Type
*Type
= pkgIndexFile::Type::GlobalList
[I
];
3316 cout
<< " Idx: " << Type
->Label
<< endl
;
3323 _("Usage: apt-get [options] command\n"
3324 " apt-get [options] install|remove pkg1 [pkg2 ...]\n"
3325 " apt-get [options] source pkg1 [pkg2 ...]\n"
3327 "apt-get is a simple command line interface for downloading and\n"
3328 "installing packages. The most frequently used commands are update\n"
3332 " update - Retrieve new lists of packages\n"
3333 " upgrade - Perform an upgrade\n"
3334 " install - Install new packages (pkg is libc6 not libc6.deb)\n"
3335 " remove - Remove packages\n"
3336 " autoremove - Remove automatically all unused packages\n"
3337 " purge - Remove packages and config files\n"
3338 " source - Download source archives\n"
3339 " build-dep - Configure build-dependencies for source packages\n"
3340 " dist-upgrade - Distribution upgrade, see apt-get(8)\n"
3341 " dselect-upgrade - Follow dselect selections\n"
3342 " clean - Erase downloaded archive files\n"
3343 " autoclean - Erase old downloaded archive files\n"
3344 " check - Verify that there are no broken dependencies\n"
3345 " changelog - Download and display the changelog for the given package\n"
3346 " download - Download the binary package into the current directory\n"
3349 " -h This help text.\n"
3350 " -q Loggable output - no progress indicator\n"
3351 " -qq No output except for errors\n"
3352 " -d Download only - do NOT install or unpack archives\n"
3353 " -s No-act. Perform ordering simulation\n"
3354 " -y Assume Yes to all queries and do not prompt\n"
3355 " -f Attempt to correct a system with broken dependencies in place\n"
3356 " -m Attempt to continue if archives are unlocatable\n"
3357 " -u Show a list of upgraded packages as well\n"
3358 " -b Build the source package after fetching it\n"
3359 " -V Show verbose version numbers\n"
3360 " -c=? Read this configuration file\n"
3361 " -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
3362 "See the apt-get(8), sources.list(5) and apt.conf(5) manual\n"
3363 "pages for more information and options.\n"
3364 " This APT has Super Cow Powers.\n");
3368 // SigWinch - Window size change signal handler /*{{{*/
3369 // ---------------------------------------------------------------------
3373 // Riped from GNU ls
3377 if (ioctl(1, TIOCGWINSZ
, &ws
) != -1 && ws
.ws_col
>= 5)
3378 ScreenWidth
= ws
.ws_col
- 1;
3382 int main(int argc
,const char *argv
[]) /*{{{*/
3384 CommandLine::Args Args
[] = {
3385 {'h',"help","help",0},
3386 {'v',"version","version",0},
3387 {'V',"verbose-versions","APT::Get::Show-Versions",0},
3388 {'q',"quiet","quiet",CommandLine::IntLevel
},
3389 {'q',"silent","quiet",CommandLine::IntLevel
},
3390 {'d',"download-only","APT::Get::Download-Only",0},
3391 {'b',"compile","APT::Get::Compile",0},
3392 {'b',"build","APT::Get::Compile",0},
3393 {'s',"simulate","APT::Get::Simulate",0},
3394 {'s',"just-print","APT::Get::Simulate",0},
3395 {'s',"recon","APT::Get::Simulate",0},
3396 {'s',"dry-run","APT::Get::Simulate",0},
3397 {'s',"no-act","APT::Get::Simulate",0},
3398 {'y',"yes","APT::Get::Assume-Yes",0},
3399 {'y',"assume-yes","APT::Get::Assume-Yes",0},
3400 {0,"assume-no","APT::Get::Assume-No",0},
3401 {'f',"fix-broken","APT::Get::Fix-Broken",0},
3402 {'u',"show-upgraded","APT::Get::Show-Upgraded",0},
3403 {'m',"ignore-missing","APT::Get::Fix-Missing",0},
3404 {'t',"target-release","APT::Default-Release",CommandLine::HasArg
},
3405 {'t',"default-release","APT::Default-Release",CommandLine::HasArg
},
3406 {'a',"host-architecture","APT::Get::Host-Architecture",CommandLine::HasArg
},
3407 {0,"download","APT::Get::Download",0},
3408 {0,"fix-missing","APT::Get::Fix-Missing",0},
3409 {0,"ignore-hold","APT::Ignore-Hold",0},
3410 {0,"upgrade","APT::Get::upgrade",0},
3411 {0,"only-upgrade","APT::Get::Only-Upgrade",0},
3412 {0,"force-yes","APT::Get::force-yes",0},
3413 {0,"print-uris","APT::Get::Print-URIs",0},
3414 {0,"diff-only","APT::Get::Diff-Only",0},
3415 {0,"debian-only","APT::Get::Diff-Only",0},
3416 {0,"tar-only","APT::Get::Tar-Only",0},
3417 {0,"dsc-only","APT::Get::Dsc-Only",0},
3418 {0,"purge","APT::Get::Purge",0},
3419 {0,"list-cleanup","APT::Get::List-Cleanup",0},
3420 {0,"reinstall","APT::Get::ReInstall",0},
3421 {0,"trivial-only","APT::Get::Trivial-Only",0},
3422 {0,"remove","APT::Get::Remove",0},
3423 {0,"only-source","APT::Get::Only-Source",0},
3424 {0,"arch-only","APT::Get::Arch-Only",0},
3425 {0,"auto-remove","APT::Get::AutomaticRemove",0},
3426 {0,"allow-unauthenticated","APT::Get::AllowUnauthenticated",0},
3427 {0,"install-recommends","APT::Install-Recommends",CommandLine::Boolean
},
3428 {0,"install-suggests","APT::Install-Suggests",CommandLine::Boolean
},
3429 {0,"fix-policy","APT::Get::Fix-Policy-Broken",0},
3430 {0,"solver","APT::Solver",CommandLine::HasArg
},
3431 {'c',"config-file",0,CommandLine::ConfigFile
},
3432 {'o',"option",0,CommandLine::ArbItem
},
3434 CommandLine::Dispatch Cmds
[] = {{"update",&DoUpdate
},
3435 {"upgrade",&DoUpgrade
},
3436 {"install",&DoInstall
},
3437 {"remove",&DoInstall
},
3438 {"purge",&DoInstall
},
3439 {"autoremove",&DoInstall
},
3440 {"markauto",&DoMarkAuto
},
3441 {"unmarkauto",&DoMarkAuto
},
3442 {"dist-upgrade",&DoDistUpgrade
},
3443 {"dselect-upgrade",&DoDSelectUpgrade
},
3444 {"build-dep",&DoBuildDep
},
3446 {"autoclean",&DoAutoClean
},
3448 {"source",&DoSource
},
3449 {"download",&DoDownload
},
3450 {"changelog",&DoChangelog
},
3455 // Set up gettext support
3456 setlocale(LC_ALL
,"");
3457 textdomain(PACKAGE
);
3459 // Parse the command line and initialize the package library
3460 CommandLine
CmdL(Args
,_config
);
3461 if (pkgInitConfig(*_config
) == false ||
3462 CmdL
.Parse(argc
,argv
) == false ||
3463 pkgInitSystem(*_config
,_system
) == false)
3465 if (_config
->FindB("version") == true)
3468 _error
->DumpErrors();
3472 // See if the help should be shown
3473 if (_config
->FindB("help") == true ||
3474 _config
->FindB("version") == true ||
3475 CmdL
.FileSize() == 0)
3481 // simulate user-friendly if apt-get has no root privileges
3482 if (getuid() != 0 && _config
->FindB("APT::Get::Simulate") == true &&
3483 (CmdL
.FileSize() == 0 ||
3484 (strcmp(CmdL
.FileList
[0], "source") != 0 && strcmp(CmdL
.FileList
[0], "download") != 0 &&
3485 strcmp(CmdL
.FileList
[0], "changelog") != 0)))
3487 if (_config
->FindB("APT::Get::Show-User-Simulation-Note",true) == true)
3488 cout
<< _("NOTE: This is only a simulation!\n"
3489 " apt-get needs root privileges for real execution.\n"
3490 " Keep also in mind that locking is deactivated,\n"
3491 " so don't depend on the relevance to the real current situation!"
3493 _config
->Set("Debug::NoLocking",true);
3496 // Deal with stdout not being a tty
3497 if (!isatty(STDOUT_FILENO
) && _config
->FindI("quiet", -1) == -1)
3498 _config
->Set("quiet","1");
3500 // Setup the output streams
3501 c0out
.rdbuf(cout
.rdbuf());
3502 c1out
.rdbuf(cout
.rdbuf());
3503 c2out
.rdbuf(cout
.rdbuf());
3504 if (_config
->FindI("quiet",0) > 0)
3505 c0out
.rdbuf(devnull
.rdbuf());
3506 if (_config
->FindI("quiet",0) > 1)
3507 c1out
.rdbuf(devnull
.rdbuf());
3509 // Setup the signals
3510 signal(SIGPIPE
,SIG_IGN
);
3511 signal(SIGWINCH
,SigWinch
);
3514 // Match the operation
3515 CmdL
.DispatchArg(Cmds
);
3517 // Print any errors or warnings found during parsing
3518 bool const Errors
= _error
->PendingError();
3519 if (_config
->FindI("quiet",0) > 0)
3520 _error
->DumpErrors();
3522 _error
->DumpErrors(GlobalError::DEBUG
);
3523 return Errors
== true ? 100 : 0;